Initial commit

Author: adamczykpiotr

.gitignore

@@ -0,0 +1,41 @@
+*.lo
+*.la
+.libs
+acinclude.m4
+aclocal.m4
+autom4te.cache
+build
+config.guess
+config.h
+config.h.in
+config.log
+config.nice
+config.status
+config.sub
+configure
+configure.ac
+configure.in
+include
+install-sh
+libtool
+ltmain.sh
+Makefile
+Makefile.fragments
+Makefile.global
+Makefile.objects
+missing
+mkinstalldirs
+modules
+php_test_results_*.txt
+phpt.*
+run-test-info.php
+run-tests.php
+tests/**/*.diff
+tests/**/*.out
+tests/**/*.php
+tests/**/*.exp
+tests/**/*.log
+tests/**/*.sh
+tests/**/*.db
+tests/**/*.mem
+tmp-php.ini

canbus.c

@@ -0,0 +1,340 @@
+/* canbus extension for PHP */
+
+#ifdef HAVE_CONFIG_H
+    # include "config.h"
+#endif
+
+#include "php.h"
+#include "ext/standard/info.h"
+#include "php_canbus.h"
+#include "canbus_arginfo.h"
+
+#include <linux/can/raw.h>  //can_frame, masks
+#include <net/if.h>         //ifreq
+#include <sys/ioctl.h>      //ioctl, SIOCGIFINDEX
+#include <unistd.h>         //read, close
+#include <fcntl.h>          //fcntl
+
+//Defines for easy class member access
+#define CANBUS_INTERFACE_P OBJ_PROP_NUM(Z_OBJ_P(ZEND_THIS), 0)
+#define CANBUS_SOCKFD_P OBJ_PROP_NUM(Z_OBJ_P(ZEND_THIS), 1)
+
+#define CANFRAME_ID_P(zv) OBJ_PROP_NUM(Z_OBJ_P(zv), 0)
+#define CANFRAME_LENGTH_P(zv) OBJ_PROP_NUM(Z_OBJ_P(zv), 1) 
+#define CANFRAME_DATA_P(zv) OBJ_PROP_NUM(Z_OBJ_P(zv), 2 )
+
+//Class entries
+zend_class_entry *canBus_ce = NULL;
+zend_class_entry *canFrame_ce = NULL;
+
+/* {{{ CanBus constructor */
+PHP_METHOD(CanBus, __construct) {
+    zend_string* interface;
+
+    //Parse arguments
+    ZEND_PARSE_PARAMETERS_START(1, 1)
+        Z_PARAM_STR(interface)
+    ZEND_PARSE_PARAMETERS_END();
+
+    //Validate interface name
+    if (ZSTR_LEN(interface) == 0) {
+        php_error_docref(NULL, E_ERROR, "interface name cannot be empty");
+    }
+
+    //Initialize $this->interface with provided name
+    ZVAL_STR_COPY(CANBUS_INTERFACE_P, interface);
+}
+/* }}} */
+
+/* {{{ CanBus init method */
+PHP_METHOD(CanBus, init) {
+    zend_bool blocking = true;
+
+    //Parse arguments
+    ZEND_PARSE_PARAMETERS_START(0, 1)
+        Z_PARAM_OPTIONAL
+        Z_PARAM_BOOL(blocking)
+    ZEND_PARSE_PARAMETERS_END();
+
+    //If socket file descriptor is set, close it before another initialization
+    zend_long sockFd = Z_LVAL_P(CANBUS_SOCKFD_P);
+    if(sockFd != -1) {
+        close(sockFd);
+    }
+
+    //Open CAN network interface
+    sockFd = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+    if (sockFd == -1) {
+        RETURN_FALSE;
+    }
+
+    //Map CAN interface
+    struct ifreq ifr;
+    zval* interface = CANBUS_INTERFACE_P;
+    strncpy(ifr.ifr_name, Z_STRVAL(*interface), IFNAMSIZ);
+    if(ioctl(sockFd, SIOCGIFINDEX, &ifr) == -1) {
+        RETURN_FALSE;
+    }
+
+    //Bind the socket to the network interface
+    struct sockaddr_can addr;
+    addr.can_family = AF_CAN;
+    addr.can_ifindex = ifr.ifr_ifindex;
+    if(bind(sockFd, (struct sockaddr*)(&addr), sizeof(addr)) == -1) {
+        RETURN_FALSE;
+    }
+
+    //Conditionaly set socket to non-blocking mode 
+    if(!blocking) {
+
+        //Get flags
+        int flags = fcntl(sockFd, F_GETFL, 0);
+        if(flags == -1) {
+            RETURN_FALSE;
+        }
+
+        //Set non-blocking flag
+        if (fcntl(sockFd, F_SETFL, flags | O_NONBLOCK) == -1) {
+            RETURN_FALSE;
+        }
+    }
+
+    //Update $this->sockFd file descriptor
+    ZVAL_LONG(CANBUS_SOCKFD_P, sockFd);
+
+    RETURN_TRUE;
+}
+/* }}} */
+
+/* {{{ CanBus read single frame method */
+PHP_METHOD(CanBus, read) {
+    struct can_frame canFrame;
+    zend_long sockFd = Z_LVAL_P(CANBUS_SOCKFD_P);
+
+    //Try to read CAN frame
+    ssize_t numBytes = read(sockFd, &canFrame, CAN_MTU);
+
+    //Return false if whole frame could not be read
+    if(numBytes != CAN_MTU) {
+        RETURN_FALSE;
+    }
+
+    //Create CanFrame object
+    zend_object *object = zend_objects_new(canFrame_ce);
+    zval frame;
+    ZVAL_OBJ(&frame, object);
+
+    //Initialize $frame->id
+    ZVAL_LONG(CANFRAME_ID_P(&frame), canFrame.can_id);
+    
+    //Initialize $frame->length
+    ZVAL_LONG(CANFRAME_LENGTH_P(&frame), canFrame.can_dlc);
+
+    //Initialize $frame->data
+    zval* data = CANFRAME_DATA_P(&frame);
+    array_init_size(data, canFrame.can_dlc);
+
+    //fill $frame->data
+    for(int i = 0; i < canFrame.can_dlc; i++) {
+        add_next_index_long(data, canFrame.data[i]);
+    }
+
+    //Return CanFrame
+    RETURN_COPY(&frame);
+}
+/* }}} */
+
+/* {{{ CanBus generate random frame */
+PHP_METHOD(CanBus, generateRandomFrame) {
+    zend_object *object = zend_objects_new(canFrame_ce);
+
+    zval frame;
+    ZVAL_OBJ(&frame, object);
+
+    //Generate random can_frame;
+    struct can_frame canFrame;
+    srand(time(NULL));
+    canFrame.can_id = rand() % 0x7FF;
+    canFrame.can_dlc = rand() % 8;
+    for(int i = 0; i < canFrame.can_dlc; i++) {
+        canFrame.data[i] = rand() % 0xFF;
+    }
+
+    //Initialize $frame->id
+    ZVAL_LONG(CANFRAME_ID_P(&frame), canFrame.can_id);
+    
+    //Initialize $frame->length
+    ZVAL_LONG(CANFRAME_LENGTH_P(&frame), canFrame.can_dlc);
+
+    //Initialize $frame->data
+    zval* data = CANFRAME_DATA_P(&frame);
+    array_init_size(data, canFrame.can_dlc);
+
+    //Fill $frame->data
+    for(int i = 0; i < canFrame.can_dlc; i++) {
+        add_next_index_long(data, canFrame.data[i]);
+    }
+
+    //Return CanFrame
+    RETURN_COPY(&frame);
+}
+/* }}} */
+
+/* {{{ CanFrame constructor */
+PHP_METHOD(CanFrame, __construct) {
+    zend_long id;
+    HashTable* data;
+
+    //Parse arguments
+    ZEND_PARSE_PARAMETERS_START(2, 2)
+        Z_PARAM_LONG(id)
+        Z_PARAM_ARRAY_HT(data)
+    ZEND_PARSE_PARAMETERS_END();
+
+    //Validate provided ID with CAN 2.0B standard (0 to 2^31 - 1)
+    if(id < 0 || id > 0x7FFFFFFF) {
+        php_error_docref(NULL, E_ERROR, "parameter ID has to be in range of 0-0x7FFFFFFF");
+    }
+
+    //Validate provided data has at most 8 elements
+    zend_long dataLength = zend_hash_num_elements(data);
+    if(dataLength > 8) {
+        php_error_docref(NULL, E_ERROR, "data length has to be not greater than 8 elements");
+    }
+
+    //Validate provided data constists only of zend_long in range of 0-255
+    zval* temp;
+    ZEND_HASH_FOREACH_VAL(data, temp) {
+        //Validate type
+        if(Z_TYPE_P(temp) != IS_LONG) {
+            php_error_docref(NULL, E_ERROR, "data element has to be an int");
+            continue;
+        } 
+
+        //Validate value
+        zend_long value = Z_LVAL_P(temp);
+        if(value < 0 || value > 0xFF) {
+            php_error_docref(NULL, E_ERROR, "data element value has to be in range od 0-0xFF");
+        }
+    } ZEND_HASH_FOREACH_END();
+
+    //Initialize $this->id with provided id
+    ZVAL_LONG(CANFRAME_ID_P(ZEND_THIS), id);
+
+    //Make copy of passed input data & initialize $this->data
+    ZVAL_ARR(CANFRAME_DATA_P(ZEND_THIS), data);
+
+    //Initialize size of passed array
+    ZVAL_LONG(CANFRAME_LENGTH_P(ZEND_THIS), dataLength);
+}
+/* }}} */
+
+/* {{{ CanBus class registry */
+static zend_class_entry *register_class_CanBus(void) {
+    zend_class_entry ce, *classEntry;
+
+    //Register class
+    INIT_CLASS_ENTRY(ce, "CanBus", class_CanBus_methods);
+    classEntry = zend_register_internal_class_ex(&ce, NULL);
+
+    //Register member: public string $id = undefined
+    zval property_interface_default_value;
+    ZVAL_UNDEF(&property_interface_default_value);
+    zend_string *property_interface_name = zend_string_init("interface", strlen("interface"), true);
+    zend_declare_typed_property(classEntry, property_interface_name, &property_interface_default_value, ZEND_ACC_PROTECTED, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING));
+    zend_string_release(property_interface_name);
+
+    //Register member: protecte int $socketFd = -1
+    zval property_socketFd_default_value;
+    ZVAL_LONG(&property_socketFd_default_value, -1);
+    zend_string *property_socketFd_name = zend_string_init("socketFd", strlen("socketFd"), true);
+
+    zend_declare_typed_property(classEntry, property_socketFd_name, &property_socketFd_default_value, ZEND_ACC_PROTECTED, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG));
+    zend_string_release(property_socketFd_name);
+
+    return classEntry;
+}
+/* }}} */
+
+/* {{{ CanFrame class registry */
+static zend_class_entry *register_class_CanFrame(void) {
+    zend_class_entry ce, *classEntry;
+
+    //Register class
+    INIT_CLASS_ENTRY(ce, "CanFrame", class_CanFrame_methods);
+    classEntry = zend_register_internal_class(&ce);
+
+    //Register member: public int $id = 0
+    zval id;
+    ZVAL_LONG(&id, 0);
+    zend_string *idName = zend_string_init("id", strlen("id"), true);
+    zend_declare_typed_property(classEntry, idName, &id, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG));
+    zend_string_release(idName);
+
+    //Register member: public int $length = 0
+    zval length;
+    ZVAL_LONG(&length, 0);
+    zend_string *lengthName = zend_string_init("length", strlen("length"), true);
+    zend_declare_typed_property(classEntry, lengthName, &length, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG));
+    zend_string_release(lengthName);
+
+    //Register member: public array $data = []
+    zval data;
+    ZVAL_EMPTY_ARRAY(&data);
+    zend_string *dataName = zend_string_init("data", strlen("data"), true);
+    zend_declare_typed_property(classEntry, dataName, &data, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_ARRAY));
+    zend_string_release(dataName);
+    
+    return classEntry;
+}
+/* }}} */
+
+/* {{{ PHP_RINIT_FUNCTION */
+PHP_RINIT_FUNCTION(canbus){
+    #if defined(ZTS) && defined(COMPILE_DL_CANBUS)
+        ZEND_TSRMLS_CACHE_UPDATE();
+    #endif
+
+    return SUCCESS;
+}
+/* }}} */
+
+ /*{{{ PHP_MINIT_FUNCTION */
+PHP_MINIT_FUNCTION(canbus) {
+    canBus_ce = register_class_CanBus();
+    canFrame_ce = register_class_CanFrame();
+
+    return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_MINFO_FUNCTION */
+PHP_MINFO_FUNCTION(canbus) {
+    php_info_print_table_start();
+    php_info_print_table_header(2, "canbus support", "enabled");
+    php_info_print_table_end();
+}
+/* }}} */
+
+/* {{{ canbus_module_entry */
+zend_module_entry canbus_module_entry = {
+    STANDARD_MODULE_HEADER,
+    "canbus",           /* Extension name */
+    NULL,               /* zend_function_entry */
+    PHP_MINIT(canbus),  /* PHP_MINIT - Module initialization */
+    NULL,               /* PHP_MSHUTDOWN - Module shutdown */
+    PHP_RINIT(canbus),  /* PHP_RINIT - Request initialization */
+    NULL,               /* PHP_RSHUTDOWN - Request shutdown */
+    PHP_MINFO(canbus),  /* PHP_MINFO - Module info */
+    PHP_CANBUS_VERSION, /* Version */
+    STANDARD_MODULE_PROPERTIES
+};
+/* }}} */
+
+#ifdef COMPILE_DL_CANBUS
+    # ifdef ZTS
+        ZEND_TSRMLS_CACHE_DEFINE()
+    # endif
+
+    ZEND_GET_MODULE(canbus)
+#endif