<?php
|
require_once(__DIR__ . '/vendor/autoload.php');
|
|
class ISM7_Connection {
|
protected $conn;
|
protected $buffer;
|
|
protected $logger;
|
protected $dumper;
|
|
public function __construct($host, $port=9091) {
|
$this->logger = Logger::getLogger('ism7.connection');
|
$this->logger->debug('Connecting to '.$host.':'.$port);
|
$this->dumper = new Clue\Hexdump\Hexdump();
|
|
$context = stream_context_create(array(
|
'tls' => array(
|
'verify_peer' => FALSE,
|
),
|
));
|
$this->conn = stream_socket_client('sslv3://'.$host.':'.$port,
|
$errno, $errstr, ini_get("default_socket_timeout"),
|
STREAM_CLIENT_CONNECT, $context);
|
if($this->conn === FALSE) {
|
throw new Exception('stream_socket_client() failed! '.$errstr.' ('.$errno.')');
|
}
|
|
$this->logger->debug('Connected to '.$host.':'.$port);
|
}
|
|
protected function send($data) {
|
$data = (string)$data;
|
$this->logger->debug('Trying to send '.strlen($data).' bytes');
|
$this->logger->trace('Send data dump:'."\n".$this->dumper->dump($data));
|
|
for($written = 0; $written < strlen($data); $written += $length) {
|
$length = fwrite($this->conn, substr($data, $written));
|
if($length === FALSE) {
|
throw new Exception('fwrite() failed!');
|
}
|
}
|
|
$this->logger->debug('Sent '.$written.' bytes');
|
}
|
|
protected function recv($bytes = 1) {
|
$this->logger->debug('Trying to receive '.$bytes.' bytes');
|
|
$bytes = (int)$bytes;
|
while(strlen($this->buffer) < $bytes) {
|
$part = fread($this->conn, $bytes - strlen($this->buffer));
|
if($part === FALSE) {
|
throw new Exception('fread() failed!');
|
}
|
$this->buffer .= $part;
|
}
|
|
$data = substr($this->buffer, 0, $bytes);
|
$this->buffer = substr($this->buffer, $bytes);
|
|
$this->logger->debug('Received '.strlen($data).' bytes');
|
$this->logger->trace('Received data dump:'."\n".$this->dumper->dump($data));
|
|
return $data;
|
}
|
|
public function communicate(ISM7_Request $request) {
|
$this->logger->debug('Sending request: '.get_class($request));
|
|
$this->send($request->getMessage());
|
|
$header = $this->recv(6);
|
$response = ISM7_Response::getByHeader($header);
|
$data = $this->recv($response->getLength());
|
$response->setData($data);
|
|
$this->logger->debug('Got response: '.get_class($response));
|
|
return $response;
|
}
|
|
public function wait() {
|
$header = $this->recv(6);
|
$response = ISM7_Response::getByHeader($header);
|
$data = $this->recv($response->getLength());
|
$response->setData($data);
|
|
$this->logger->debug('Got push request: '.get_class($response));
|
|
return $response;
|
}
|
|
public function close() {
|
fclose($this->conn);
|
}
|
}
|
|
abstract class ISM7_Message {
|
protected static $typeToId = array(
|
'PortalLogonRequest' => 0,
|
'PortalLogonResponse' => 1,
|
'ReadSystemconfigRequest' => 2,
|
'ReadSystemconfigResponse' => 3,
|
'TelegramBundleRequest' => 4,
|
'TelegramBundleResponse' => 5,
|
'DirectLogonRequest' => 8,
|
'DirectLogonResponse' => 9,
|
);
|
protected static $idToType = NULL;
|
|
protected $address;
|
protected $type;
|
|
protected static $logger;
|
|
public function __construct($className, $address = 0) {
|
if(!self::$logger) {
|
self::$logger = Logger::getLogger('ism7.message');
|
}
|
|
$this->address = (int)$address;
|
assert(0 <= $this->address && $this->address <= 0xFFFF);
|
$this->type = substr($className, strpos($className, '_') + 1);
|
assert(isset(self::$typeToId[$this->type]));
|
}
|
|
public function getAddress() {
|
return $this->address;
|
}
|
public function getType() {
|
return $this->type;
|
}
|
public function getTypeId() {
|
return self::getIdByType($this->type);
|
}
|
|
protected static function getIdByType($type) {
|
return self::$typeToId[$type];
|
}
|
protected static function getTypeById($id) {
|
if(self::$idToType === NULL) {
|
self::$idToType = array_flip(self::$typeToId);
|
}
|
return self::$idToType[$id];
|
}
|
}
|
|
abstract class ISM7_Request extends ISM7_Message {
|
public function __construct($className, $address = 0) {
|
parent::__construct($className, $address);
|
}
|
|
function getMessage() {
|
$message = $this->getData();
|
$header = pack('nnn', $this->getAddress(), strlen($message), $this->getTypeId());
|
|
return $header . $message;
|
}
|
|
abstract function getData();
|
}
|
|
class ISM7_Response extends ISM7_Message {
|
private $length;
|
protected $data;
|
|
public function __construct($className, $address = 0) {
|
parent::__construct($className, $address);
|
}
|
|
public function getLength() {
|
return $this->length;
|
}
|
protected function setHeader($header) {
|
$this->address = $header['address'];
|
$this->length = $header['length'];
|
}
|
|
public static function getByHeader($header) {
|
$headerDecoded = unpack('naddress/nlength/ntype', $header);
|
$className = 'ISM7_' . ISM7_Message::getTypeById($headerDecoded['type']);
|
self::$logger->debug('Response seems to be '.$className);
|
|
$response = new $className();
|
$response->setHeader($headerDecoded);
|
return $response;
|
}
|
|
protected function setData($data) {
|
$this->data = new DOMDocument('1.0', 'utf-8');
|
$this->data->loadXML($data);
|
}
|
}
|
|
class ISM7_DirectLogonRequest extends ISM7_Request {
|
private $password;
|
|
public function __construct($password = '1111') {
|
parent::__construct(__CLASS__);
|
$this->password = (string)$password;
|
}
|
|
public function getData() {
|
$xml = new DOMDocument('1.0', 'utf-8');
|
$rootNode = $xml->createElement('direct-logon-request');
|
$xml->appendChild($rootNode);
|
$passNode = $xml->createElement('password');
|
$rootNode->appendChild($passNode);
|
$passText = $xml->createTextNode($this->password);
|
$passNode-> appendChild($passText);
|
return $xml->saveXML();
|
}
|
}
|
|
class ISM7_DirectLogonResponse extends ISM7_Response {
|
protected $sid;
|
protected $installationName;
|
protected $serialNumber;
|
protected $dateTime;
|
protected $softwareVersion;
|
protected $hardwareVersion;
|
protected $moduleType;
|
protected $wlanConnected;
|
|
public function __construct() {
|
parent::__construct(__CLASS__);
|
}
|
|
public function setData($data) {
|
parent::setData($data);
|
$rootNode = $this->data->documentElement;
|
assert($rootNode->tagName == 'direct-logon-response');
|
assert($rootNode->hasAttribute('state'));
|
assert(strtolower($rootNode->getAttribute('state')) == 'ok');
|
assert($rootNode->hasAttribute('sid'));
|
$this->sid = (string)$rootNode->getAttribute('sid');
|
|
foreach($rootNode->childNodes as $childNode) {
|
$text = trim((string)$childNode->textContent);
|
|
self::$logger->trace('DirectLogonResponse::setData(): '.$childNode->nodeName.'='.$text);
|
|
switch($childNode->nodeName) {
|
case 'installationname':
|
$this->installationName = $text;
|
break;
|
case 'serialnumber':
|
$this->serialNumber = $text;
|
break;
|
case 'date-time':
|
$this->dateTime = new DateTime($text);
|
break;
|
case 'ism-softwareversion':
|
$this->softwareVersion = $text;
|
break;
|
case 'ism-hardwareversion':
|
$this->hardwareVersion = $text;
|
break;
|
case 'type':
|
$this->moduleType = $text;
|
break;
|
case 'wlan-connected':
|
$this->wlanConnected = (strtolower($text) == 'true');
|
break;
|
default:
|
self::$logger->info('DirectLogonResponse::setData(): unknown tag '.$childNode->nodeName);
|
}
|
}
|
}
|
|
public function getSid() {
|
return $this->sid;
|
}
|
}
|
|
abstract class ISM7_Element {
|
protected static $logger;
|
|
public function __construct() {
|
if(!self::$logger) {
|
self::$logger = Logger::getLogger('ism7.element');
|
}
|
}
|
}
|
|
class ISM7_Systemconfig_Gateway extends ISM7_Element {
|
protected $gatewayType;
|
protected $softwareNumber;
|
protected $softwareVersion;
|
protected $wlan;
|
protected $g3;
|
|
public function __construct(DOMNode $node) {
|
parent::__construct();
|
|
foreach($node->attributes as $attribute) {
|
$text = $attribute->nodeValue;
|
self::$logger->trace('Systemconfig_Gateway: '.$attribute->nodeName.'='.$text);
|
|
switch($attribute->nodeName) {
|
case 'type':
|
$this->gatewayType = $text;
|
break;
|
case 'softwareNumber':
|
$this->softwareNumber = $text;
|
break;
|
case 'softwareVersion':
|
$this->softwareVersion = $text;
|
break;
|
case 'wlan':
|
$this->wlan = ($text == 'true');
|
break;
|
case 'g3':
|
$this->g3 = ($text == 'true');
|
break;
|
default:
|
self::$logger->info('Systemconfig_Gateway: unknown attribute '.$childNode->nodeName);
|
}
|
}
|
}
|
}
|
|
class ISM7_Systemconfig_Bus extends ISM7_Element {
|
protected $busType;
|
protected $devices = array();
|
|
public function __construct(DOMNode $node) {
|
parent::__construct();
|
|
if($node->hasAttribute('type')) {
|
$this->busType = $node->getAttribute('type');
|
}
|
|
foreach($node->childNodes as $childNode) {
|
self::$logger->trace('Systemconfig_Bus: '.$childNode->nodeName);
|
if($childNode->nodeName == 'busDevices') {
|
foreach($childNode->childNodes as $device) {
|
self::$logger->trace('Systemconfig_Bus: '.$device->nodeName);
|
assert($device->nodeName == 'busDevice');
|
$this->devices[] = new ISM7_Systemconfig_BusDevice($device);
|
}
|
} else {
|
self::$logger->info('Systemconfig_Bus: unknown tag '.$childNode->nodeName);
|
}
|
}
|
}
|
}
|
|
class ISM7_Systemconfig_BusDevice extends ISM7_Element {
|
protected $address;
|
protected $softwareNumber;
|
protected $softwareVersion;
|
protected $configuration;
|
protected $deviceId;
|
|
public function __construct(DOMNode $node) {
|
parent::__construct();
|
|
foreach($node->attributes as $attribute) {
|
$text = $attribute->nodeValue;
|
self::$logger->trace('Systemconfig_BusDevice: '.$attribute->nodeName.'='.$text);
|
|
switch($attribute->nodeName) {
|
case 'ba':
|
$this->address = hexdec($text);
|
break;
|
case 'sv':
|
$this->softwareNumber = hexdec($text);
|
break;
|
case 'sr':
|
$this->softwareVersion = hexdec($text);
|
break;
|
case 'cfg':
|
$this->configuration = hexdec($text);
|
break;
|
case 'did':
|
$this->deviceId = hexdec($text);
|
break;
|
default:
|
self::$logger->info('Systemconfig_BusDevice: unknown attribute '.$attribute->nodeName);
|
}
|
}
|
}
|
}
|
|
class ISM7_ReadSystemconfigRequest extends ISM7_Request {
|
private $sid;
|
|
public function __construct($sid = '1') {
|
parent::__construct(__CLASS__);
|
$this->sid = (string)$sid;
|
}
|
|
public function getData() {
|
$xml = new DOMDocument('1.0', 'utf-8');
|
$rootNode = $xml->createElement('read-systemconfig-request');
|
$rootNode->setAttribute('sid', $this->sid);
|
$xml->appendChild($rootNode);
|
return $xml->saveXML();
|
}
|
}
|
|
class ISM7_ReadSystemconfigResponse extends ISM7_Response {
|
protected $gateway;
|
protected $bus;
|
|
public function __construct() {
|
parent::__construct(__CLASS__);
|
}
|
|
public function setData($data) {
|
parent::setData($data);
|
|
$rootNode = $this->data->documentElement;
|
assert($rootNode->tagName == 'read-systemconfig-response');
|
foreach($rootNode->childNodes as $childNode) {
|
$text = trim((string)$childNode->textContent);
|
|
self::$logger->trace('ReadSystemconfigResponse::setData(): parsing '.$childNode->nodeName);
|
|
switch($childNode->nodeName) {
|
case 'gateway':
|
$this->gateway = new ISM7_Systemconfig_Gateway($childNode);
|
break;
|
case 'busconfig':
|
$this->bus = new ISM7_Systemconfig_Bus($childNode);
|
break;
|
default:
|
self::$logger->info('ReadSystemconfigResponse::setData(): unknown tag '.$childNode->nodeName);
|
}
|
}
|
}
|
}
|
|
interface ISM7_XML_Part {
|
public function getXmlPart($xml = NULL);
|
}
|
interface ISM7_XML_Parent {
|
public function append(ISM7_XML_Part $part);
|
}
|
|
class ISM7_Telegram_InfonumberRead extends ISM7_Element implements ISM7_XML_Part {
|
protected $sequence;
|
protected $address;
|
protected $infonumber;
|
protected $interval;
|
|
function __construct($sequence = NULL, $address = NULL, $infonumber = NULL, $interval = NULL) {
|
parent::__construct();
|
if($sequence === NULL && $address === NULL && $infonumber === NULL && $interval === NULL) {
|
return;
|
}
|
|
if($address instanceof ISM7_Systemconfig_BusDevice) {
|
$address = $address->address;
|
}
|
|
$this->sequence = (string)$sequence;
|
$this->address = (int)$address;
|
$this->infonumber = (int)$infonumber;
|
$this->interval = (int)$interval;
|
}
|
|
public function getXmlPart($xml = NULL) {
|
if(!($xml instanceof DOMDocument)) {
|
$xml = new DOMDocument('1.0', 'utf-8');
|
}
|
|
$rootNode = $xml->createElement('ird');
|
$rootNode->setAttribute('se', $this->sequence);
|
$rootNode->setAttribute('ba', '0x'.dechex($this->address));
|
$rootNode->setAttribute('in', $this->infonumber);
|
|
if($this->interval) {
|
$rootNode->setAttribute('is', $this->interval);
|
}
|
|
return $rootNode;
|
}
|
}
|
|
class ISM7_Telegram_Infonumber extends ISM7_Telegram_InfonumberRead {
|
protected $value = 0;
|
|
public function __construct(DOMNode $node) {
|
parent::__construct();
|
|
assert($node->hasAttribute('st'));
|
assert($node->getAttribute('st') == 'OK');
|
|
assert($node->hasAttribute('dh'));
|
assert($node->hasAttribute('dl'));
|
$this->value = (hexdec($node->getAttribute('dh')) << 8) | hexdec($node->getAttribute('dl'));
|
if($this->value > 127 * 256) {
|
$value -= 256 * 256;
|
}
|
self::$logger->trace('Telegram_Infonumber: d='.$this->value);
|
|
foreach($node->attributes as $attribute) {
|
$text = $attribute->nodeValue;
|
self::$logger->trace('Telegram_Infonumber: '.$attribute->nodeName.'='.$text);
|
|
switch($attribute->nodeName) {
|
case 'se':
|
$this->sequence = $text;
|
break;
|
case 'ba':
|
$this->address = hexdec($text);
|
break;
|
case 'in':
|
$this->infonumber = (int)$text;
|
break;
|
case 'dh':
|
case 'dl':
|
case 'st':
|
break;
|
default:
|
self::$logger->info('Systemconfig_BusDevice: unknown attribute '.$attribute->nodeName);
|
}
|
}
|
}
|
|
public function __get($name) {
|
return $this->$name;
|
}
|
}
|
|
class ISM7_TelegramBundleRequest extends ISM7_Request implements ISM7_XML_Parent {
|
protected $xml;
|
protected $rootNode;
|
|
protected $bundle;
|
protected $gateway;
|
protected $abortOnError;
|
protected $telegramType;
|
|
public function __construct($bundle = 1, $gateway = 1, $abortOnError = FALSE, $telegramType = 'pull') {
|
parent::__construct(__CLASS__);
|
|
assert(in_array($telegramType, array('pull', 'push', 'write', 'remove', 'clear')));
|
|
$this->bundle = (int)$bundle;
|
$this->gateway = (int)$gateway;
|
$this->abortOnError = (bool)$abortOnError;
|
$this->telegramType = (string)$telegramType;
|
|
$this->xml = new DOMDocument('1.0', 'utf-8');
|
$this->rootNode = $this->xml->createElement('tbreq');
|
$this->xml->appendChild($this->rootNode);
|
}
|
|
public function append(ISM7_XML_Part $part) {
|
$node = $part->getXmlPart($this->xml);
|
assert($node->nodeName == 'ird' || $node->nodeName == 'erd');
|
|
$this->rootNode->appendChild($node);
|
}
|
|
public function getData() {
|
$this->rootNode->setAttribute('bn', $this->bundle);
|
$this->rootNode->setAttribute('gw', $this->gateway);
|
$this->rootNode->setAttribute('ae', ($this->abortOnError ? 'true' : 'false'));
|
$this->rootNode->setAttribute('ty', $this->telegramType);
|
|
return $this->xml->saveXML();
|
}
|
}
|
|
class ISM7_TelegramBundleResponse extends ISM7_Response implements IteratorAggregate {
|
protected $bundle;
|
protected $gateway;
|
protected $dateTime;
|
protected $errorMessage;
|
|
protected $infonumbers = array();
|
|
public function __construct() {
|
parent::__construct(__CLASS__);
|
}
|
|
public function setData($data) {
|
parent::setData($data);
|
|
$rootNode = $this->data->documentElement;
|
assert($rootNode->tagName == 'tbres');
|
assert($rootNode->hasAttribute('st'));
|
assert($rootNode->getAttribute('st') == 'OK');
|
|
assert($rootNode->hasAttribute('bn'));
|
assert(ctype_digit($rootNode->getAttribute('bn')));
|
$this->bundle = (int)$rootNode->getAttribute('bn');
|
|
assert($rootNode->hasAttribute('gw'));
|
assert(ctype_digit($rootNode->getAttribute('gw')));
|
$this->gateway = (int)$rootNode->getAttribute('gw');
|
|
if($rootNode->hasAttribute('ts')) {
|
$this->dateTime = new DateTime($rootNode->getAttribute('ts'));
|
self::$logger->trace('TelegramBundleResponse::setData(): timestamp: '.$this->dateTime->format('Y-m-d H:i:s'));
|
}
|
if($rootNode->hasAttribute('emsg') && $rootNode->getAttribute('emsg')) {
|
self::$logger->warn('TelegramBundleResponse::setData(): error message: '.$rootNode->getAttribute('emsg'));
|
}
|
|
foreach($rootNode->childNodes as $childNode) {
|
$text = trim((string)$childNode->textContent);
|
|
self::$logger->trace('TelegramBundleResponse::setData(): parsing '.$childNode->nodeName);
|
|
switch($childNode->nodeName) {
|
case 'irs':
|
$this->infonumbers[] = new ISM7_Telegram_Infonumber($childNode);
|
break;
|
default:
|
self::$logger->info('TelegramBundleResponse::setData(): unknown tag '.$childNode->nodeName);
|
}
|
}
|
}
|
|
public function getIterator() {
|
return new ArrayIterator($this->infonumbers);
|
}
|
}
|
