<?php
/*
************************************************************************
**
**	Copyright (c) 2009, 2010 by
**		Core|Vision B.V.
**		Cereslaan 10b
**		5384 VT  Heesch
**		The Netherlands
**
**	All Rights Reserved
**
************************************************************************
*/
/*
************************************************************************
**
**	Project name:   Dual Inventive: MTinfo and web support scripts
**	Filename:       cp3000-tcpclient.php (formerly zkl-tcpclient.php)
**	Author:			Jack Weeland
**	Date:			January 28, 2009
**	File version:	1.00	of January 28, 2009
**					1.10	of February 23, 2009
**							- A socket open with 'fsockopen()' is a file
**							  resource and _not_ a socket :-S
**							  In casu, it cannot be used for 'socket_select()'.
**							- 'socket_read()' reads only _one_ of \n and \r.
**					1.20	of November 30, 2009
**							- Suport for Switch3000 and PM3000.
**					2.00	of September 20, 2010
**							- Uses PHP extension "cp3000"
**
************************************************************************
*/
/*
************************************************************************
**
**	CP3000 client
**
************************************************************************
*/

/*
**	Constants
*/

//
//	How to connect to a device?
//

// for the parameter $alarmmsg to 'zkl_tcplogin()'
define("ZKL_NORMAL",				0);		// TCP-server
define("ZKL_STATUS",				1);		// TCP-server, but status updates are passed through
define("ZKL_SHMEM",					2);		// shared memory (cached status only)

//
//	Return and status codes
//

// okay
define("TCPSTAT_OK",			  0x00);
define("TCPSTAT_WARNING",		  0x02);	// okay, but only partially
define("TCPSTAT_BADSTATE",		  0x03);	// state is not as expected, but still okay(ish)
define("TCPSTAT_SKIPPED",		  0x04);	// Skipped

// end of file (on the communication socket)
define("TCPERR_EOF",			  0x01);

// protocol errors
define("TCPERR_INVAL",			  0x10);	// invalid command or parameter
define("TCPERR_PARAM",			  0x11);	// parameter count wrong
define("TCPERR_TOOLONG",		  0x12);	// parameter too long
define("TCPERR_INTERR",			  0x13);	// internal error
define("TCPERR_CHKSUM",			  0x14);	// checksum error
define("TCPERR_STALE",			  0x15);	// data has expired
define("TCPERR_FILEERR",		  0x16);	// file error (see 'errno' for details)

// transient errors, can be retried
define("TCPERR_BUSY",			  0x40);	// too many connections from database servers (try again)
define("TCPSTAT_BUSY",			(TCPERR_BUSY));
define("TCPERR_ABORTED",		  0x41);	// server terminated; try to connect again
define("TCPERR_TOOMANY",		  0x42);	// too many connections (peer can try again)

// server errors, cannot be retried1
define("TCPERR_ACCESS",			  0x80);	// access denied
define("TCPERR_NOFIFO",			  0x81);	// local communication fifo does not exist
define("TCPERR_DISC",			  0x82);	// zkl closed its connection
define("TCPERR_UNKNOWN",		  0x83);	// zkl not in the database
define("TCPERR_CONNECT",		  0x84);	// connection refused (server not running?)
define("TCPERR_SOCKET",			  0x85);	// socket error on read or write
define("TCPERR_TIMEOUT",		  0x86);	// time-out
define("TCPERR_NOSUPP",			  0x87);	// operation not supported
define("TCPERR_NOMEM",            0x88);	// out of memory
define("TCPERR_BUFSZ",            0x89);	// buffer too small
define("TCPERR_NODATA",           0x8A);	// data source exhausted
define("TCPERR_DATACHG",		  0x8B);	// data changed while this is not allowed
define("TCPERR_LOCKED",			  0x8C);	// access denied because a user or some functionality is locked
define("TCPERR_BADSTATE",		  0x8D);	// the current state is not expected or faulty
define("TCPERR_DEVICE",			  0x8E);	// generic device error
define("TCPERR_GEOFENCE",		  0x8F);	// geo-fencing error

// intermediate result - real result code will follow
define("TCPSTAT_INTERMEDIATE",	  0xFF);

//
//	Fields changed for the real-time status update
//
define("STATUPDATE_STATE",		0x0001);	// global mcu state flags
define("STATUPDATE_WCPU_STATE",	0x0002);	// global wcpu state flags
define("STATUPDATE_RC",			0x0004);	// remote control state flags (incl. pm3000)
define("STATUPDATE_SWITCH",		0x0008);	// switch3000 state flags
define("STATUPDATE_RMS",		0x0010);	// detection: RMS value of the measurement (V_ref)
define("STATUPDATE_B_A",		0x0020);	// b/a of the measurement
define("STATUPDATE_AUTOCAL",	0x0080);	// calibratie b/a and PWM frequency
define("STATUPDATE_BATTSEL",	0x0800);	// battery selection changed
define("STATUPDATE_BATT1LVL",	0x0100);	// battery voltage update
define("STATUPDATE_BATT2LVL",	0x0200);	// battery voltage update
define("STATUPDATE_INTTEMP",	0x1000);	// on-board temperature update
define("STATUPDATE_EXTTEMP",	0x2000);	// ntc temperature or switch3000 update
define("STATUPDATE_GPS",		0x4000);	// update for gps co-ordinates, speed and heading (and hdop and time)
define("STATUPDATE_GSM",		0x8000);	// gsm signal quality and connectivity update
define("STATUPDATE_NEW",		     0);	// fresh status update (all fields contain new values)
define("STATUPDATE_ANY",		0xFFFF);	// fresh status update (all fields contain new values)

//
//	Fields for the status array ['mcu']['state']
//
define("MCUSTAT_MEASUREMENT",		0x0001);
define("MCUSTAT_DETECTION_OK",		0x0002);
define("MCUSTAT_MEASUREMENT_FAIL",	0x0004);
define("MCUSTAT_RELAY_OPEN",		0x0008);
// system initialization errors and state
define("MCUERR_NONE",				0x0000);
define("MCUERR_I2C",				0x0010);	// I2C failure (MCU->WCPU path)
define("MCUERR_LOG",				0x0020);	// µALFAT or SD-card failure
define("MCUERR_GSM",				0x0040);	// WCPU unreachable
define("MCUERR_SMS",				0x0080);	// not used
define("MCUERR_ANY",				0x00F0);
// battery status
define("MCUSTAT_BATTERY_OK",		0);
define("MCUSTAT_BATTERY_LOW",		1);
define("MCUSTAT_BATTERY_CRITICAL",	2);
define("MCUSTAT_BATTERY_ABSENT",	3);
define("MCUSTAT_BATTERY1_LOW",		(1 << (MCUSTAT_BATTERY_LOW      +  7)));
define("MCUSTAT_BATTERY1_CRITICAL",	(1 << (MCUSTAT_BATTERY_CRITICAL +  7)));
define("MCUSTAT_BATTERY1_ABSENT",	(1 << (MCUSTAT_BATTERY_ABSENT   +  7)));
define("MCUSTAT_BATTERY2_LOW",		(1 << (MCUSTAT_BATTERY_LOW      + 11)));
define("MCUSTAT_BATTERY2_CRITICAL",	(1 << (MCUSTAT_BATTERY_CRITICAL + 11)));
define("MCUSTAT_BATTERY2_ABSENT",	(1 << (MCUSTAT_BATTERY_ABSENT   + 11)));
define("MCUSTAT_BATTERY",			0xFF00);	// combination of all battery status flags
define("MCUSTAT_BATTERY1",			0x0F00);
define("MCUSTAT_BATTERY2",			0xF000);

//
//	Fields for the status array ['mcu']['local state']
//
define("MCULOC_IN_SWEEP",			0x0003);	// sweep busy
define("MCULOC_IN_FREQ_SWEEP",		0x0001);	//	frequency sweep
define("MCULOC_IN_AMPL_SWEEP",		0x0002);	//	amplitude sweep
define("MCULOC_GPSPOWER",			0x0008);	// GPS power enabled (for trace & trace)
define("MCULOC_GPS_RECEIVED",		0x0010);	// GPS co-ordinates received
define("MCULOC_RTC_RECEIVED",		0x0020);	// clock data received
define("MCULOC_LED",				0x0040);	// LED intensity is "high" / deprecated 20091111
define("MCULOC_LANTERN",			0x0080);	// lantern is "on" / deprecated 20091111
define("MCULOC_AUTOCAL",			0x0100);	// auto-calibration enabled
define("MCULOC_AUTOCAL_FAIL",		0x0200);	// auto-calibration failed (internal state)
define("MCULOC_EXT_CONTACT",		0x0400);	// external contact enabled
define("MCULOC_RELAY_DRIVER",		0x0800);	// relay driver enabled
define("MCULOC_GSM_ENABLED",		0x2000);	// GSM is ready
define("MCULOC_TCP_CONNECTED",		0x4000);	// logged in with TCP server
define("MCULOC_INIT_DONE",			0x8000);	// MCU is initialized

//
//	Fields for the status array ['mcu']['persistent']
//
define("MCUFLG_AUTOCAL_DONE",		0x0001);	// device is calibrated
define("MCUFLG_SW3000_AVAILABLE",	0x0004);	// device is equiped with a Switch 3000 module
define("MCUFLG_PM3000_AVAILABLE",	0x0008);	// device is equiped with a Power Management 3000 module
define("MCUFLG_MEASUREMENT",		0x0010);	// measurement busy
define("MCUFLG_MEASUREMENT_RC",		0x0020);	// measurements turned on remotely
define("MCUFLG_MEASUREMENT_KEY",	0x0040);	// measurements turned on with the key
define("MCUFLG_SW3000_ENABLED",		0x0080);	// Switch 3000 is enabled
define("MCUFLG_BATTERY_MASK",		0xFF00);
// Battery type (t) and voltage (v) for battery #1 (b=0) or #2 (b=1)
// MCUFLG_BATTERY_TYPE(b,t,v)		((((t) << 2) | (v)) << (8 + (4*b)))
define("MCUFLG_BATT_NiMH",			0);		// default: NiMH battery
define("MCUFLG_BATT_NiCd",			1);		// option: NiCd battery
define("MCUFLG_BATT_LiIon",			2);		// option: LiIon or LiPolymer battery
define("MCUFLG_BATT_Alkaline",		3);		// option: alkaline battery (1.5V per cell instead of 1.2V)
// (when MCUFLG_BATT_Li is _not_ set)
define("MCUFLG_BATT_12V",			0);		// default: 12V battery
define("MCUFLG_BATT_6V",			1);		// option: 6V battery
define("MCUFLG_BATT_24V",			3);		// option: 24V battery
// (when MCUFLG_BATT_Li is set - currently only MCUTYPE_ZKL3000_RC)
define("MCUFLG_BATT_7_2V",			0);		// default: 7.2V battery
define("MCUFLG_BATT_10_8V",			1);		// option: 10.8V
define("MCUFLG_BATT_14_4V",			2);		// option: 14.4V
define("MCUFLG_BATT_3_6V",			3);		// (not for a ZKL, but other devices with a 3.6/3.7 V LiIon battery)

//
//	Fields for the status array ['mcu']['remote control status']
//
define("MCURC_MEASUREMENT_ON",		0x0001);	// transient state: measurements are turned on from MTinfo
define("MCURC_DETECTION_OK",		0x0002);	// detection status (short circuit between the rails detected)
												//	when the Switch3000 was turned on or off
define("MCURC_KEY_SWITCH_ON",		0x0004);	// key for Switch3000 is "on"
define("MCURC_KEY_SWITCH_OFF",		0x0008);	// key for Switch3000 is "off"
define("MCURCERR_SWI2C",			0x0010);	// software I2C error
define("MCURCERR_SW1W",				0x0020);	// software 1-Wire error
define("MCURCERR_SW3000",			0x0020);	// (alias)
define("MCURCERR_PM3000",			0x0040);	// PM3000 failure
define("MCURCERR_ANY",				0x0070);	//
define("MCURC_PM_SW3000_ON",		0x0080);	// Switch 3000 power always on
define("MCURC_PM_SWITCH1",			0x0100);	// power management: switch 1 is "on" (Switch 3000)
define("MCURC_PM_SWITCH2",			0x0200);	// power management: switch 2 is "on" (undefined)
define("MCURC_PM_CHARGE",			0x0400);	// power management: charging LiIon battery
define("MCURC_PM_BOOST",			0x0800);	// transient state: 9V boost for the analogue circuit enabled
define("MCURC_GPS_POWER_ON",		0x1000);	// transient state: GPS (5V circuit) powered up
define("MCURC_PM_CHARGE_MANUAL",	0x2000);	// battery charger controlled manually
define("MCURC_SW3000_ONESHOT",		0x4000);	// Switch 3000: one shot measurement
define("MCURC_STATUS_VALID",		0x8000);	// transient state: status is retrieved for Switch 3000
												//	and it ready to be read (the flag will disappear
												//	immediately after that)
//
//	Fields for the status array ['mcu']['switch3000 status']
//
define("MCUSW_SEC1_ON",				0x0001);	// section #1 is enabled
define("MCUSW_SEC2_ON",				0x0002);	// section #2 is enabled
define("MCUSW_SEC3_ON",				0x0004);	// section #3 is enabled
define("MCUSW_SEC4_ON",				0x0008);	// section #4 is enabled
define("MCUSW_SEC_NONE",			0x0000);	// (placeholder)
define("MCUSW_SEC_ALL",				0x000F);	// (all sections)
define("MCUSWERR_TIMEOUT",			0x0010);	// time-out error
define("MCUSWERR_ERROR",			0x0020);	// generic error, most likely in the 1-Wire signaling
define("MCUSW_SEC1_BATT_OK",		0x0100);	// battery for section #1 is okay
define("MCUSW_SEC2_BATT_OK",		0x0200);	// battery for section #2 is okay
define("MCUSW_SEC3_BATT_OK",		0x0400);	// battery for section #3 is okay
define("MCUSW_SEC4_BATT_OK",		0x0800);	// battery for section #4 is okay
define("MCUSW_SECE_BATT_OK",		0x8000);	// battery for emergency section is okay
define("MCUSW_SEC_ALL_BATT",		0x8F00);	// (all batteries)

//
//	Wireless CPU status (used internally in the WCPU)
//
define("WCPUERR_NONE",			0x00000000);
define("WCPUERR_INTERNAL",		0x00000001);	// WCPU internal datastructure failed to initialize
define("WCPUERR_GPRS",			0x00000002);	// GPRS or TCP failure
define("WCPUERR_SMS",			0x00000004);	// SMS service couldn't be started
define("WCPUERR_SIM",			0x00000008);	// SIM or SIM service failed
define("WCPUERR_UART1",			0x00000010);	// UART1 failure (MCU->WCPU path)
define("WCPUERR_UART2",			0x00000020);	// UART2 failure (WCPU<->GPS path)
define("WCPUERR_I2C",			0x00000040);	// I2C error (WCPU->MCU path)
define("WCPUERR_MCU",			0x00000080);	// MCU does not respond on I2C bus
define("WPCUERR_ANY",			0x000000FF);
// Actived modules
define("GSMACTIVE_GSM",			0x00000100);
define("GSMACTIVE_SIM",			0x00000200);
define("GSMACTIVE_GPRS",		0x00000400);
define("GSMACTIVE_TCP",			0x00000800);
define("GSMACTIVE_GPS",			0x00001000);
define("GSMACTIVE_SMS",			0x00002000);
define("GSMACTIVE_SSL",			0x00004000);
define("GSMACTIVE_RTOS",		0x00008000);	// _never_ in wcpu_flags (feature only)
// Others
define("WCPUERR_TEMP_ONBOARD",	0x00100000);	// on-board temperature over threshold
define("WCPUERR_TEMP_EXT1",		0x00200000);	// NTC temperature over threshold
define("WCPUERR_TEMP_EXT2",		0x00400000);	// (reserved)
define("WCPUERR_TEMP_SW3000",	0x00800000);	// Switch 3000 temperature over threshold
define("WCPUSTAT_GPS_FIX",		0x00008000);	// GPS fix quality indicator set
define("WCPUSTAT_GEOFENCE_INSIDE", 0x00080000);	// inside a geofence
// Log replay state (for debugging purposes)
define("WPCULOG_ENABLED",		0x00010000);	// connected to the server for streaming data
define("WCPULOG_STALLED",		0x00020000);	// stalled because data cannot be sent immediately
// WCPULOG_REQ(what)			((u32)(what) << (16 + 8))
define("WCPULOG_REQ_NEW",			0x01);		// pending request for new file, no reply
define("WCPULOG_REQ_CONT",			0x02);		// pending request, same file, not yet replied
define("WCPULOG_REQ_ABORT",			0x03);		// log reply is aborted
define("WCPULOG_REQ_ERROR",			0x08);		// error detected
define("WCPULOG_REQ_ACK",			0x10);		// request was acknowledge, orred with REQ_NEW or REQ_CONT
define("WCPULOG_REQ_READING",		0x20);		// reading data from MCU, orred with REQ_NEW or REQ_CONT
define("WCPULOG_REQ_PROCESSING",	0x30);		// processing log data
define("WCPULOG_REQ_NEXT",			0x40);		// requesting next file from TCP-server
define("WCPULOG_REQ_LISTING",		0x80);		// sending directory listing to TCP-server
define("WCPULOG_REQ_DONE",			0xF0);		// current log file completed
define("WCPULOG_REQ_IDLE",			0x00);		// log replay not yet started
define("WCPULOG_REQ_MASK",			0xF0);		// mask request state (inverted) and overall state

/*
**	Globals
*/

// status of the last transfer or command
global $zkl_status, $zkl_error;
$zkl_status = 0;
$zkl_error = "";

/*
**	Private functions
*/

//
//	Calculate the checksum of a message
//
function calc_checksum($buffer)
{
	$checksum = 0;
	$ptr      = 0;

	// skip initial $ or !
	if( $buffer[0] == '$' || $buffer[0] == '!' )
		$buffer = substr($buffer, 1);
	while( strlen($buffer) != 0 && $buffer[0] != "*" )
	{
		// read a quoted string up to the end quote
		if( $buffer[0] == '"' ) {
			do {
				$checksum ^= ord($buffer);
				
				if( $buffer[0] == '\\' ) {
					// escaped character
					$buffer = substr($buffer, 1);
					$checksum ^= ord($buffer);
					$buffer = substr($buffer, 1);
				}
				else {
					$buffer = substr($buffer, 1);
				}
				// return immediately when there is no ending quote
				if( strlen($buffer) == 0 ) return -1;
			} while( $buffer[0] != '"' );
		}
		
		$checksum ^= ord($buffer);
		$buffer = substr($buffer, 1);
	}

	return $checksum & 255;
}

// append the second array to the first - PHP doesn't have this function...
function array_append(&$array1, $array2)
{
	foreach( $array2 as $item ) $array1[] = $item;
}

// wait for one or more sockets, with a timeout
// $sockets, an array with sockets to wait for, will be modified
function wait_for_sockets(&$sockets, &$timeout)
{
	return cp3000_wait_data($sockets, $timeout);
}

// wait for a single socket, with a timeout
function wait_for_socket($socket, &$timeout)
{
	return cp3000_wait_data($socket, $timeout);
}

//
//	Send a command, contained in '$fmt', over the socket. The command '$fmt'
//	can contains format specifiers for 'sprintf()', the arguments for which
//	are provided in the array '$args'.
//	The checksum is calculated for resulting command, after expansion of
//	'$args' and this is sent to the TCP server.
//
function zkl_send_command($socket, $fmt, $args = NULL)
{
	global $zkl_status, $zkl_error;
  
  if( !$fmt ) {
    // library crashes on an empty string ($ forgotten?)
		$zkl_status = TCPERR_SOCKET;
		$zkl_error = "cp3000_send_data(): invalid NULL command";
    return FALSE;
  }

	// send command, with checksum
	$cmd = cp3000_tokens2cmd(vsprintf($fmt, $args));
	if( @cp3000_send_data($socket, $cmd) === FALSE ) {
		$zkl_status = TCPERR_SOCKET;
		$zkl_error = "cp3000_send_data(): " . cp3000_error_string($socket, $zkl_status);
		return FALSE;
	}
	// DEBUGGING: else echo "--[" . microtime() . "]-> " . $cmd . "\n";
	
	return TRUE;
}

//
//	Queue retrieval of the value of a key.
//	The value must read using 'zkl_read_result()'
//
function zkl_queue_retrieval($socket, $key)
{
	// send the command, its arguments and the checksum
	if( zkl_send_command($socket, "\$RETR,\"%s\"", $key) === FALSE )
		return FALSE;
}

//
//	Read the result of the previous command from the socket and tokenize it.
//	Also used for asynchronous replies.
//
function zkl_read_result($socket, &$result, $timeout = NULL)
{
	global $zkl_status, $zkl_error;

	// read result
	$result = "";
	do {
		$reply = @cp3000_read_data($socket, $timeout);
		if( $reply === FALSE ) {
			if( $timeout == 0.0 )
				$zkl_status = TCPERR_TIMEOUT;
			else
				$zkl_status = TCPERR_SOCKET;
			$zkl_error = "cp3000_read_data(): " . cp3000_error_string($socket, $zkl_status);
			return $zkl_status;
		}
		// DEBUGGING: else echo "<-[" . microtime() . "]-- " . strlen($reply) . ": " . $reply . "\n";

		if( $reply[0] == '!' ) {	    		    
			$tokens = cp3000_cmd2tokens($reply);
			$zkl_status = $tokens['status'];
		
			// save error in '$zkl_error'
			if( $zkl_status != TCPSTAT_OK && $zkl_status != TCPSTAT_INTERMEDIATE && $zkl_status != TCPSTAT_WARNING && $zkl_status != TCPSTAT_BADSTATE ) {
				$zkl_error = $tokens['args'][0];
			}

			// save result and/or error string
			if( is_array($tokens['args']) ) {
				if( $result  ) $result .= ",";
				$result .= implode(",", $tokens['args']);
			}
		}
	} while( $zkl_status == TCPSTAT_INTERMEDIATE || $reply[0] == '$' );
	
	return $zkl_status;
}

/*
**	Low level functions
*/

//
//	Send a command to the TCP-server and wait for its reply
//	When a time-out is not needed, pass NULL as the second argument to this function
//
function zkl_command($socket, $timeout, $fmt)
{
	// send the command, its arguments and the checksum
	$args = func_get_args();
	$args = array_slice($args, 3);
	if( zkl_send_command($socket, $fmt, $args) === FALSE )
		return FALSE;

	if( zkl_read_result($socket, $result, $timeout) != TCPSTAT_OK )
		return FALSE;
	else return $result;
}

/*
**	Global functions
*/

//
//	Security (SSL): set private key
//
//	Inputs:
//		$key        - private key (name of a PEM encoded file)
//		$passphrase - passphrase for the key, a filename of a raw (!) file
//		              containing the actual passphrase; this file must only
//		              the passphrase, i.e. it must not have line endings
//		              or comments or whatever (or rather: the _entire_ file
//		              contents is used as the passphrase)
//
function zkl_set_private_key($key, $passphrase)
{
	global $_SECURITY;
	
	if( !isset($_SECURITY) ) $_SECURITY = array();

	$_SECURITY['private']['key'] = $key;
	$_SECURITY['private']['passphrase'] = $passphrase;
}

//
//	Security (SSL): set public key
//
//	Inputs:
//		$cert   - "my" certificate (name of a PEM encoded file)
//		$signer - certificate of the CA that signed "my" certificate
//		          (name of a PEM encoded file)
//
function zkl_set_public_key($cert, $signer)
{
	global $_SECURITY;
	
	if( !isset($_SECURITY) ) $_SECURITY = array();

	$_SECURITY['public']['cert']  = $cert;
	$_SECURITY['public']['trust'] = $signer;
}

//
//	Login with the TCP-server
//
//	Inputs:
//		$zkl            - database ID of the ZKL
//		$server         - hostname:port with which to connect
//		$priv_key       - NOT USED, use "zkl_set_private_key()" instead
//		$pub_key        - NOI USED, use "zkl_set_public_key()" instead
//		$alarmmsg       - this channel is for alarm messages ($alarmmsg = TRUE)
//		                  or retrieve or storing keys on the ZKL (the default,
//		                  $alarmmsg = FALSE)
//		$timeout        - Max timeout of the $DB command
//		$shmem_fallback - When shmem failed, login?
//
//	Returns:
//		CP3000 channel descriptor for reading and writing (historically
//		called a socket)
//
function zkl_tcplogin($zkl, $server, $priv_key = NULL, $pub_key = NULL, $alarmmsg = ZKL_NORMAL, $timeout = 3, $shmem_fallback = TRUE)
{
	global $zkl_status, $zkl_error;
	global $_SECURITY, $_HOSTNAME;
	
    // Setup connection to shared memory object or TCP-server
	// Isolate the host name to test if it is an alias for the local host
	$host = $server;
	$host_pos = strpos($host, ":");
	if( $host_pos !== FALSE ) $host = substr($host, 0, $host_pos);
	// try shared memory object and semaphore - fallback to TCP if the shared memory object
	//	or the semaphore can't be opened
	// NB: string parameter to 'cp3000_sysv_key()' _must_ be correctly
	//	formatted, i.e. don't change this
	if(
		$alarmmsg == ZKL_SHMEM &&
		isset($_HOSTNAME) &&
		(is_array($_HOSTNAME) ? in_array($host, $_HOSTNAME) : $host == $_HOSTNAME) &&
		(
			$shm_id = @shmop_open(
				cp3000_sysv_key($server . "-" . sprintf("%u", $zkl) . "-shm"),
				"a",
				0,
				0
			)
		) !== FALSE &&
		(
			$semaphore = @sem_get(
				cp3000_sysv_key($server . "-" . sprintf("%u", $zkl) . "-sem")
			)
		) !== FALSE
	) {
		// shared memory object and semaphore are available
		return array('shm' => $shm_id, 'sem' => $semaphore);
	}
	else {
		if (($alarmmsg != ZKL_SHMEM) || ($shmem_fallback)) {
		    // TCP-server or TCP-server Secure
		    if( isset($_SECURITY) ) {
		    	$socket = @cp3000_connect(
		    		$server,
		    		$_SECURITY['public']['cert'],
		    		$_SECURITY['public']['trust'],
		    		$_SECURITY['private']['key'],
		    		$_SECURITY['private']['passphrase']
		    	);
		    }
		    else $socket = @cp3000_connect($server);
        
        // connected?
   	    if( !$socket ) {
            return FALSE;        
   	    }  
	        
		    // login
		    if( zkl_command($socket, $timeout, "\$DB,%u,%d", $zkl, $alarmmsg ? 1 : 0) === FALSE ) {
		    	@cp3000_close($socket);
		    	return FALSE;
		    }
		    else return $socket;
		}
		else {
		    return FALSE;
		}
	}
}

//
//	Set up connection with server
//
//	Inputs:
//		$server   - hostname:port with which to connect
//
function zkl_connect($server)
{
	return @cp3000_connect($server);
}

//
//	Disconnect connection
//
function zkl_disconnect($socket)
{
	@cp3000_close($socket);
	return TRUE;
}

//
//	Logout from TCP-server (trivial...)
//
function zkl_tcplogout($socket)
{
	if( is_cp3000($socket) ) {
		zkl_disconnect($socket);
	}
	else {
		@shmop_close($socket['shm']);
		// nothing special needed for the semaphore
	}
	return TRUE;
}

//
//	Is the connection a TCP connection?
//
function zkl_via_tcp($socket)
{
	return is_cp3000($socket);
} 

//
//	Get peer name
//
//	Returns:
//		- SSL common name of the peer, as determined by its certificate;
//		- hostname (reverse DNS look-up, or IP addres if not found) for
//		  unsecure connections
//
function zkl_get_peername($socket)
{
	if( is_cp3000($socket) ) return @cp3000_get_peername($socket);
	else return "<shmem>";
}

//
//	Retrieve the value of a key
//
function zkl_retrieve($socket, $key, $timeout = NULL)
{
	return zkl_command($socket, $timeout, "\$RETR,\"%s\"", $key);
}

//
//	Store the value of a key
//
function zkl_store($socket, $key, $value)
{
	return zkl_send_command($socket, "\$STOR,\"%s\",\"%s\"", array($key, $value)) !== FALSE;
}

/*
**	High level functions
*/

//
//	Get real-time status
//	Return an associative array
//
function zkl_get_status($socket, $timeout = NULL)
{
	if( !is_cp3000($socket) ) return FALSE;

	return zkl_interpret_status(zkl_retrieve($socket, "STAT", $timeout));
}

function zkl_get_cached_status($socket, $timeout = NULL)
{
	if( is_cp3000($socket) ) {
		$status = zkl_command($socket, $timeout, "\$STAT");
	}
	else {
		// 256 bytes _should_ be long enough to contain the status string
		//	(at the moment, 20101027, it is about 140 bytes or less)
		@sem_acquire($socket['sem']);
		$status = @shmop_read($socket['shm'], 0, 256);
		@sem_release($socket['sem']);
		// trim the string - PHP strings are a bit awkward as it is a strange
		//	mix between C type strings and byte arrays with a length field;
		//	'strrpos()' in one of those functions that treats it as a byte
		//	array so we trim the data read from shared memory to the length
		//	of the C string it contains
		$pos_eos = strpos($status, "\0");
		if( $pos_eos !== FALSE ) $status = substr($status, 0, $pos_eos);
	}
	
	return zkl_interpret_status($status);
}

function zkl_interpret_status($statbuf)
{
	if( !$statbuf ) return FALSE;

	$seqnr_pos = strrpos($statbuf, "@");
	if( $seqnr_pos !== FALSE ) {
		$seqnr_time = substr($statbuf, $seqnr_pos + 1);
		$statbuf = substr($statbuf, 0, $seqnr_pos);
		$time_pos = strpos($seqnr_time, ".");
		if( $time_pos) {
			$status['time'] = intval(substr($seqnr_time, $time_pos + 1));
			$seqnr_time = substr($seqnr_time, 0, $time_pos);
		}
		else $status['time'] = 0;
		$status['seqnr'] = intval($seqnr_time);
	}
	else $status['seqnr'] = -1;
	
	$statbuf = explode(",", $statbuf);

	// gather status bitfields; will be expanded
	$mcu_state = array();
	$has_switch_status = preg_match("|([0-9A-F]{4})/([0-9A-F]{4})/([0-9A-F]{4})|", $statbuf[0], $mcu_state) > 0;
	if( $has_switch_status ) {
		$statbuf[0] = $mcu_state[1];
	}
	$status['mcu']['status']      = intval($statbuf[0], 16);
	$status['mcu']['local state'] = intval($statbuf[1], 16);
	$status['mcu']['persistent']  = intval($statbuf[2], 16);
	$wcpu_status = trim($statbuf[3]);
	if( strlen($wcpu_status) == 8 && intval("80000000", 16) != 0x80000000 ) {
		// argh! the conversion on 32-bit, which the most significant bit set, goes gaga
		// the log status is stripped because it corrupts the conversion on 32-bit system
		//	(and it is not interesting anyway)
		$status['wcpu']['status'] =
			(intval(substr($wcpu_status, 2, 2), 16) << 16) +
			(intval(substr($wcpu_status, 4, 4), 16) <<  0);
	}
	else {
		// on 64-bit systems...
		$status['wcpu']['status'] = intval($statbuf[3], 16);
	}
	if( $has_switch_status ) {
		// remote control and switch 3000 status
		$status['mcu']['remote control status'] = intval($mcu_state[2], 16);
		$status['mcu']['switch3000 status'] = intval($mcu_state[3], 16);
	}
	// measurement info
	$status['detection']['error']       = ($status['mcu']['status'] & 0x0004) != 0;
	$status['detection']['calibrated']  = ($status['mcu']['persistent'] & 0x0001) != 0;
	$status['detection']['b/a limit']   = floatval($statbuf[4]);
	$status['detection']['freq']        = floatval($statbuf[5]);
	if( $status['mcu']['status'] & 0x0001 ) {
		$status['detection']['active']  = TRUE;
		$status['detection']['rms']     = intval($statbuf[6], 10);
		$status['detection']['b/a']     = floatval($statbuf[7]);
		$status['detection']['quality'] = zkl_measurement_quality($status['detection']['b/a'], $status['detection']['b/a limit']);
		$status['detection']['ok']      = ($status['mcu']['status'] & 0x0002) != 0;
	}
	else {
		$status['detection']['active']  = FALSE;
		$status['detection']['rms']     = 0;
		$status['detection']['b/a']     = 0;
		$status['detection']['quality'] = 0;
		$status['detection']['ok']      = FALSE;
	}
	// special, transient status flags
	$status['detection']['sweep']['enabled']    = ($status['mcu']['local state'] & 0x0003) != 0;
	$status['detection']['auto-cal']['enabled'] = ($status['mcu']['local state'] & 0x0100) != 0;
	$status['detection']['auto-cal']['failure'] = ($status['mcu']['local state'] & 0x0200) != 0;
	// power management and switch 3000
	if( $has_switch_status ) {
		if( $status['mcu']['persistent'] & MCUFLG_PM3000_AVAILABLE ) {
			$status['pm3000']['switch3000']['on'] = ($status['mcu']['remote control status'] & 0x0100) != 0;
			$status['pm3000']['charger']['on']    = ($status['mcu']['remote control status'] & 0x0400) != 0;
			$status['pm3000']['switch #2']['on']  = ($status['mcu']['remote control status'] & 0x0200) != 0;
		}
		if( $status['mcu']['persistent'] & MCUFLG_SW3000_AVAILABLE ) {
			$status['switch3000']['on'] = ($status['mcu']['switch3000 status'] & 0x0009) == 0x0009
			                           || ($status['mcu']['switch3000 status'] & 0x0006) == 0x0006;
			$status['switch3000']['key']['on']       = ($status['mcu']['remote control status'] & 0x0004) != 0;
			$status['switch3000']['key']['off']      = ($status['mcu']['remote control status'] & 0x0008) != 0;
			$status['switch3000']['detection']['ok'] = ($status['mcu']['remote control status'] & 0x0002) != 0;
            $status['switch3000']['enabled']         = ($status['mcu']['persistent'] & MCUFLG_SW3000_ENABLED) != 0;
            
			// switch 3000 batteries
			$status['batt']['switch3000']['sec1']['status'] = ($status['mcu']['switch3000 status'] & 0x0100) != 0 ? "ok" : "alarm";
			$status['batt']['switch3000']['sec2']['status'] = ($status['mcu']['switch3000 status'] & 0x0200) != 0 ? "ok" : "alarm";
			$status['batt']['switch3000']['sec3']['status'] = ($status['mcu']['switch3000 status'] & 0x0400) != 0 ? "ok" : "alarm";
			$status['batt']['switch3000']['sec4']['status'] = ($status['mcu']['switch3000 status'] & 0x0800) != 0 ? "ok" : "alarm";
			$status['batt']['switch3000']['emer']['status'] = ($status['mcu']['switch3000 status'] & 0x8000) != 0 ? "ok" : "alarm";           
		}
	}
	// relay
	$status['relay']['open'] = ($status['mcu']['status'] & 0x0008) != 0;
	$status['relay']['enabled'] = ($status['mcu']['local state'] & 0x0800) != 0;
	// external contact, led intensity and lantern
	$status['external contact']['enabled'] = ($status['mcu']['local state'] & 0x0400) != 0;
	$status['led']['high']        = ($status['mcu']['local state'] & 0x0040) != 0;
	$status['led']['intensity']   = ($status['mcu']['local state'] & 0x0040) != 0 ? "high" : "low";
	$status['lantern']['enabled'] = ($status['mcu']['local state'] & 0x0080) != 0;
	// batteries; battery number is zero-based
	$status['batt']['select']     = intval($statbuf[8], 10);
	if( $status['batt']['select'] > 0 ) $status['batt']['select'] -= 1;
	$status['batt'][0]['V']       = floatval($statbuf[9]);
	$status['batt'][1]['V']       = floatval($statbuf[10]);
	if( $status['mcu']['status'] & 0x0400 )
		$status['batt'][0]['status']  = "removed";
	else if( $status['mcu']['status'] & 0x0200 )
		$status['batt'][0]['status']  = "empty";
	else if( $status['mcu']['status'] & 0x0100 )
		$status['batt'][0]['status']  = "alarm";
	else
		$status['batt'][0]['status'] = "ok";
	if( $status['mcu']['status'] & 0x4000 )
		$status['batt'][1]['status']  = "removed";
	else if( $status['mcu']['status'] & 0x2000 )
		$status['batt'][1]['status']  = "empty";
	else if( $status['mcu']['status'] & 0x1000 )
		$status['batt'][1]['status']  = "alarm";
	else
		$status['batt'][1]['status'] = "ok";
	// temperature
	$status['temp']['on-board']['C']    = (strlen($statbuf[11]) > 0) ? floatval($statbuf[11]) : NULL;
	$status['temp']['ext1']['C']        = (strlen($statbuf[12]) > 0) ? floatval($statbuf[12]) : NULL;

	$status['temp']['ext2']['C']        = FALSE;
	$status['temp']['switch3000']['C']  = FALSE;
	$status['temp']['on-board']['ok']   = (($status['wcpu']['status'] & WCPUERR_TEMP_ONBOARD) == 0);
	$status['temp']['ext1']['ok']       = (($status['wcpu']['status'] & WCPUERR_TEMP_EXT1) == 0);
	$status['temp']['ext2']['ok']       = (($status['wcpu']['status'] & WCPUERR_TEMP_EXT2) == 0);
	$status['temp']['switch3000']['ok'] = (($status['wcpu']['status'] & WCPUERR_TEMP_SW3000) == 0);
	// motion
	$status['motion']['active'] = ($status['mcu']['status'] & 0x00800000) != 0;
	$status['motion']['start']  = ($status['mcu']['status'] & 0x00C00000) == 0x00C00000;
	$status['motion']['stop']   = ($status['mcu']['status'] & 0x00C00000) == 0x00400000;
	// GSM reception
	$status['gsm']['enabled']          = ($status['mcu']['local state'] & 0x2000) != 0;
	$status['gsm']['connected']        = ($status['wcpu']['status'] & 0x0100) != 0;
	$status['gsm']['gprs connected']   = ($status['wcpu']['status'] & 0x0400) != 0;
	$status['gsm']['tcp/ip connected'] = ($status['wcpu']['status'] & 0x0800) != 0;
	$status['gsm']['sim initialized']  = ($status['wcpu']['status'] & 0x0200) != 0;
	$status['gsm']['received signal strength'] = floatval($statbuf[13]);
	$status['gsm']['bit error rate']           = intval($statbuf[14], 10);
	if( $status['gsm']['bit error rate'] != -1 ) {
		if( $status['gsm']['bit error rate'] == 0 )
			$status['gsm']['min error pct'] = 0;
		else
			$status['gsm']['min error pct'] = pow(2.0, $status['gsm']['bit error rate']) / 10;
		$status['gsm']['max error pct'] = pow(2.0, $status['gsm']['bit error rate'] + 1) / 10;
	}
	// GPS reception
	$status['gps']['enabled']   = TRUE;			// obsolete
	$status['gps']['latitude']  = floatval($statbuf[15]);
	$status['gps']['longitude'] = floatval($statbuf[16]);
	$status['gps']['altitude']  = floatval($statbuf[17]);
	$status['gps']['hdop']      = floatval($statbuf[18]);
	$status['gps']['speed']     = floatval($statbuf[19]);
	$status['gps']['heading']   = floatval($statbuf[20]);
	$status['gps']['tijd']      = intval($statbuf[21]);
	$status['gps']['fix'] = ($status['wcpu']['status'] & 0x8000) != 0;
	switch( substr($statbuf[18], -1) ) {
		case 'A':	// fix: autonomous
		case 'D':	// fix: differential (DGPS)
		case 'E':	// fix: estimated (dead reckoning)
		case 'I':	// no fix: initialized from MCU
		case 'N':	// no fix
		case 'U':	// no fix, device is initializing
			$status['gps']['mode'] = substr($statbuf[18], -1);
			break;
		default:
			unset($status['gps']['mode']);
			break;
	}
	$status['gps']['track&trace'] = ($status['mcu']['local state'] & 0x0008) != 0;
	$status['geofence']['inside'] = ($status['wcpu']['status'] & 0x80000) != 0;
	// subsystem errors
	$status['system']['error']['i2c']   = ($status['mcu']['status'] & 0x0010) != 0
	                                   || ($status['wcpu']['status'] & 0x0040) != 0;
	$status['system']['error']['log']   = ($status['mcu']['status'] & 0x0020) != 0;
	$status['system']['error']['gsm']   = ($status['mcu']['status'] & 0x0040) != 0;
	$status['system']['error']['sms']   = ($status['mcu']['status'] & 0x0080) != 0;
	$status['system']['error']['wcpu']  = ($status['wcpu']['status'] & 0x0001) != 0;
	$status['system']['error']['gprs']  = ($status['wcpu']['status'] & 0x0002) != 0;
	$status['system']['error']['tcp']   = ($status['wcpu']['status'] & 0x0002) != 0;
	$status['system']['error']['uart']  = ($status['wcpu']['status'] & 0x0010) != 0;
	$status['system']['error']['gps']   = ($status['wcpu']['status'] & 0x0020) != 0;	// UART2 actually
	$status['system']['error']['mcu']   = ($status['wcpu']['status'] & 0x0080) != 0;
	if( $has_switch_status ) {
		$status['system']['error']['swi2c'] = ($status['mcu']['remote control status'] & 0x0010) != 0;
		$status['system']['error']['sw1w']  = ($status['mcu']['remote control status'] & 0x0020) != 0;
	}
	$status['system']['ok'] =
		($status['mcu']['status'] & 0x00F0) == 0  &&
		($status['wcpu']['status'] & 0x00FF) == 0 &&
		(!$has_switch_status || ($status['mcu']['remote control status'] & 0x00F0) == 0);
	// in initialisation phase?
	$status['system']['init'] = ($status['mcu']['local state'] & 0x8000) == 0;
	
	return $status;
}

//
//	Quality of the measurement (rather arbitrary calculation)
//
function zkl_measurement_quality($b_a_measurement, $b_a_autocal)
{
	require_once("utilities.php");

	// the ZKL is calibrated at 150 mOhm, with a margin of 1.5% (1/64)
	//	in the calculation below we'll use a margin of 3%; the closer
	//	b/a diverges to the calibrated value, the less the quality will
	//	be; above the calibrate value the quality is 0.0, below the
	//	mentioned 3% is 1.0 (100%)
	// measuring with a 150 mOhm resistor will therefore show a quality
	//	of 50%
	// the 3% margin is chosen rather arbitrarily and it indicates to
	//	the user that the measurment is near the detection margin and that
	//	he/she should try to place the ZKL anew.
	//	the percentage at with quality is 100% can be adjusted below by
	//	setting the correct value for $q_good.
	return CalcShortCircuitQuality($b_a_autocal, $b_a_measurement);
}

//
//	Get a (well, the last) measurement
//
function zkl_get_measurement($socket, $timeout = NULL)
{
	$buffer = zkl_retrieve($socket, "DEBUG[MEASUREMENT]", $timeout);
	if( $buffer === FALSE ) return FALSE;

	$buffer = explode(",", $buffer);
	
	$samples = array();
	$samples['count'] = intval($buffer[0]);
	$samples['b/a']   = floatval($buffer[1]) / 65536.0;
	$samples['t_lat'] = floatval($buffer[4]);
	$samples['t_seq'] = floatval($buffer[5]);
	$samples['v_ref']['rms']  = intval($buffer[2]);
	$samples['v_meas']['rms'] = intval($buffer[3]);
	
	$buffer_ptr = 6;
	for( $array = 0; $array < 4; $array++ ) {
		// determine in which array to put the samples
		switch( $array ) {
			case 0:
				$signal = 'v_ref';
				$type   = 'raw';
				break;
			case 1:
				$signal = 'v_meas';
				$type   = 'raw';
				break;
			case 2:
				$signal = 'v_ref';
				$type   = 'filtered';
				break;
			case 3:
				$signal = 'v_meas';
				$type   = 'filtered';
				break;
		}

		// collect the samples
		$sample_array = array();
		for( $sample = 0; $sample < $samples['count']; $sample++ ) {
			$val = intval($buffer[$buffer_ptr++], 16);
			if( $val & 0x8000 ) {
				// 2's complement negative number
				$val -= 0x10000;
			}
			array_push($sample_array, $val);
		}

		// save the samples in the main array
		$samples[$signal][$type] = $sample_array;
	}

	// done
	return $samples;
}

/*
**	Functions for real-time status updates
*/

//
//	Wait until one of the ZKLs has a new status
//	Input:
//		$sockets - array of sockets, opened with a function call like
//			'zkl_tcplogin($id, $tcp_server, $priv_key, $pub_key, TRUE)'
//		$timeout - time-out in seconds (floating point number)
//	Output:
//		- array with one or more items as below; each ZKL that has a
//			status update will be in this array; ZKLs that didn't present
//			a new status will _not_ be in the array
//		  items in entry of the array
//		  - ['zkl']   - database ID of the ZKL
//		  - ['flags'] - which data is updated; bit field with one or more
//		                'STATUPDATE_xxx' bits set.
//		  - ['stat']  - status array; see 'zkl_interpret_status()'
//		- empty array when the time-out expired
//		- FALSE on error
//
function zkl_wait($sockets, $timeout = NULL)
{
	$n = wait_for_sockets($sockets, $timeout);
	
	// check the result
	if( !$n )
		// error
		return FALSE;
	else {
		$result = array();
		
		if( $n ) foreach( $sockets as $socket ) {
			$reply = @cp3000_read_data($socket, $timeout);
			if( $reply === FALSE ) {
				$zkl_status = TCPERR_SOCKET;
				$zkl_error = "socket_read(): " . cp3000_error_string($socket, $zkl_status);
				continue;
			}
			// DEBUGGING: else echo "--[" . microtime() . "]-- " . $reply . "\n";

			$tokens = cp3000_cmd2tokens($reply);
			array_push($result,
				array(
					'zkl' => $tokens['client'],
					'flags' => intval($tokens['args'][0], 10),
					'stat' => zkl_interpret_status($tokens['args'][1])
				)
			);
		}
		
		return $result;
	}
}

/*
**	Send an SMS
*/

//
//	Send an SMS
//	Input:
//		$server - the SMS server
//		$da     - destination address (the phone number) _or_ an array with
//				  (at least) 'telefoonnr' and 'imsi' to send an SMS to a
//				  device (M2M API aware)
//		$msg    - the message to send
//		$wait   - wait for reply if TRUE
//	Output:
//		FALSE if an error occured, reply from the SMS server it $wait is TRUE
//		of simply TRUE when $wait is FALSE.
//
//		The globals $zkl_status and $zkl_error will be set when an error occurs
//
function zkl_send_sms($server, $da, $msg, $wait = TRUE)
{
	global $zkl_status, $zkl_error;

	if( strlen($msg) > 160 ) {
		$zkl_status = TCPERR_INVAL;
		return FALSE;
	}
	
	require_once("m2mapi.php");

	$success = TRUE;
	if( !is_array($da) || !m2mapi_enabled_for_device($da) ) {
		// open the socket to the server
		$socket = cp3000_connect($server);
		if( !$socket ) {
			$zkl_status = TCPERR_CONNECT;
			return FALSE;
		}
	
		if( !zkl_send_command($socket, "\$SENDSMS,\"%s\",\"%s\"", array($da, $msg)) ) {
			// $zkl_status set by 'zkl_send_command()'
			$success = FALSE;
		}
		else if( $wait ) {
			$success = ((zkl_read_result($socket, $zkl_status, 15.0) == TCPSTAT_OK) && ($zkl_status == TCPSTAT_OK));
		}
	
		// done
		cp3000_close($socket);
	}
	else {
		// send to the device using the M2M API (Vodafone Smart Services)
		$success = m2mapi_send_sms($da['imsi'], $msg);
	}
	return $success;
}

//
//	Send SMS messages to multiple recipients on the same server
//	Input:
//		$server - the SMS server
//		$msgs   - array with destiantion address (key 'da') and messages (key 'msg')
//				  as:
//					$msgs = array(
//						array('da' => '+31612345678', 'msg' => 'Text for the first recipient'),
//						array('da' => '+31687654321', 'msg' => 'Text for the second recipient'),
//						// etc
//					);
//		$wait   - wait for reply if TRUE
//	Output:
//		FALSE if an error occured, TRUE otherwise (_not_ a message index on success)
//
function zkl_send_multi_sms($server, $msgs, $wait = FALSE)
{
	global $zkl_status, $zkl_error;
	$success = TRUE;
	
	// open the socket to the server
	$socket = cp3000_connect($server);
	if( !$socket ) {
		$zkl_status = TCPERR_CONNECT;
		return FALSE;
	}
	
	foreach( $msgs as $msg ) {
		if( !$msg['da'] || !$msg['msg'] || strlen($msg['msg']) > 160 ) {
			$zkl_status = TCPERR_INVAL;
			$success = FALSE;
		}
		else if( !zkl_send_command($socket, "\$SENDSMS,\"%s\",\"%s\"", array($msg['da'], $msg['msg'])) ) {
			$success = FALSE;
		}
		else if( $wait && !zkl_read_result($socket, $reply, 15.0) ) {
			$success = FALSE;
		}
	}
	
	// done
	cp3000_close($socket);
	return $success;
}
	
//
// Build an array with version information from '$str' (which is retrieved from the database)
//
function zkl_get_fw_version($str)
{
	$p = 0;
	$ver = array();
	
	$ver['major'] = 0;
	while( ctype_digit(substr($str, $p, 1))  )
		$ver['major'] = $ver['major'] * 10 + (ord(substr($str, $p++, 1)) - ord("0"));
	
	$ver['minor'] = 0;
	if( ord(substr($str, $p, 1)) == ord(".") ) {
		$p++;
		while( ctype_digit(substr($str, $p, 1))  )
			$ver['minor'] = $ver['minor'] * 10 + (ord(substr($str, $p++, 1)) - ord("0"));
	}

	$ver['release'] = 0;
	if( ord(substr($str, $p, 1)) == ord(".") ) {
		$p++;
		while( ctype_digit(substr($str, $p, 1))  )
			$ver['release'] = $ver['release'] * 10 + (ord(substr($str, $p++, 1)) - ord("0"));
	}

	$ver['update'] = 0;
	if( ord(substr($str, $p, 1)) == ord(".") ) {
		$p++;
		while( ctype_digit(substr($str, $p, 1))  )
			$ver['update'] = $ver['update'] * 10 + (ord(substr($str, $p++, 1)) - ord("0"));
	}
		
	$ver['datecode'] = 0;
	if( ord(substr($str, $p, 1)) == ord("-") ) {
		$p++;
		while( ctype_digit(substr($str, $p, 1))  )
			$ver['datecode'] = $ver['datecode'] * 16 + (ord(substr($str, $p++, 1)) - ord("0"));
	}
	
	$ver['devtype'] == "";
	if( ord(substr($str, $p, 1)) == ord("-") ) {
		$p++;
		$ver['devtype'] = substr($str, $p);
	}
	
	return $ver;
}

?>