handle.c

#include "handle.h"

zend_class_entry *alpm_ce_handle;

static int le_handle;

#define HANDLE_GETOBJECT() \
    zval *this = getThis(); \
    handle_object *intern; \
    zval *res; \
    if (this) { \
        intern = Z_HANDLEO_P(this); \
        if (!intern) { \
            RETURN_FALSE; \
        } \
    }


static zend_function_entry handle_methods[] = {
    PHP_ME(Handle, __construct,   NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)

    PHP_ME(Handle, add_cachedir,  NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Handle, add_ignoregrp, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, add_ignorepkg, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, add_noextract, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, add_noupgrade, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, get_localdb, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, get_syncdbs, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, init_transaction, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, load_pkg, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, register_syncdb, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, remove_cachedir, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, remove_ignoregrp, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, remove_ignorepkg, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, remove_noextract, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, remove_noupgrade, NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, set_pkgreason, NULL, ZEND_ACC_PUBLIC)

    {NULL, NULL, NULL}
};

zend_object *create_handle_struct(zend_class_entry *class TSRMLS_DC) {
    handle_object *handle;

    handle = (handle_object*)emalloc(sizeof(handle_object));
    memset(handle, 0, sizeof(handle_object));

    zend_object_std_init(&handle->std, class TSRMLS_CC);
//    zend_hash_copy(handle->std.properties, &class->properties_info, (copy_ctor_func_t) zval_add_ref);

    return &handle->std;
}

void alpm_init_handle(TSRMLS_D) {
    zend_class_entry ce;

    INIT_CLASS_ENTRY(ce, "Handle", handle_methods);
    alpm_ce_handle = zend_register_internal_class(&ce TSRMLS_CC);

    zval *cd = (zval*)malloc(sizeof(zval));
    zval *ig = (zval*)malloc(sizeof(zval));
    zval *ip = (zval*)malloc(sizeof(zval));
    zval *ne = (zval*)malloc(sizeof(zval));
    zval *nu = (zval*)malloc(sizeof(zval));

    ce.create_object = create_handle_struct;

    zend_declare_property_string(alpm_ce_handle, "arch", sizeof("arch") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property(alpm_ce_handle, "cachedirs", sizeof("cachedirs") - 1, cd, ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_long(alpm_ce_handle, "checkspace", sizeof("checkspace") - 1, 0, ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "dbpath", sizeof("dbpath") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_double(alpm_ce_handle, "deltaratio", sizeof("deltaratio") - 1, 0.0, ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "dlcb", sizeof("dlcb") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "eventcb", sizeof("eventcb") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "fetchcb", sizeof("fetchcb") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "gpgdir", sizeof("gpgdir") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property(alpm_ce_handle, "ignoregrps", sizeof("ignoregrps") - 1, ig, ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property(alpm_ce_handle, "ignorepkgs", sizeof("ignorepkgs") - 1, ip, ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "logcb", sizeof("logcb") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "logfile", sizeof("logfile") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property(alpm_ce_handle, "noextracts", sizeof("noextracts") - 1, ne, ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property(alpm_ce_handle, "noupgrades", sizeof("noupgrades") - 1, nu, ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "progresscb", sizeof("progresscb") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "questioncb", sizeof("questioncb") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "root", sizeof("root") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_string(alpm_ce_handle, "totaldlcb", sizeof("totaldlcb") - 1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
    zend_declare_property_long(alpm_ce_handle, "usesyslog", sizeof("usesyslog") - 1, 0, ZEND_ACC_PUBLIC TSRMLS_CC);
}

PHP_METHOD(Handle, __construct) {
    char *rootpath;
    char *dbpath;
    size_t rp, dp;
    zval cd, ig, ip, ne, nu;

    array_init(&cd);
    array_init(&ig);
    array_init(&ip);
    array_init(&ne);
    array_init(&nu);

    HANDLE_GETOBJECT()

//    intern = (handle_object *)zend_fetch_resource(Z_RES_P(res), "handle", le_handle);


    if (ZEND_NUM_ARGS() == 0) {
        rootpath = malloc(sizeof(char) * strlen("/"));
        dbpath = malloc(sizeof(char) * strlen("/"));

        strcpy(rootpath, "/");
        strcpy(dbpath, "/");

        rp = strlen(rootpath);
        dp = strlen(dbpath);

        goto create;
    }
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &rootpath, &rp, &dbpath, &dp) == FAILURE) {
        RETURN_NULL()
    }

    create:
    object_init_ex(return_value, alpm_ce_handle);

    /* none of this seems to be working... */
    alpm_errno_t err;
    alpm_handle_t *_handle = alpm_initialize(rootpath, dbpath, &err);
    php_printf("Test: %s", alpm_option_get_dbpath(_handle)); /* prints "Test: (null)" */
    /* end */

    zend_update_property_stringl(alpm_ce_handle, getThis(), "root", sizeof("root") - 1, rootpath, rp TSRMLS_CC);
    zend_update_property(alpm_ce_handle, getThis(), "cachedirs", sizeof("cachedirs") - 1, &cd TSRMLS_CC);
    zend_update_property_stringl(alpm_ce_handle, getThis(), "dbpath", sizeof("dbpath") - 1, dbpath, dp TSRMLS_CC);
    zend_update_property(alpm_ce_handle, getThis(), "ignoregrps", sizeof("ignoregrps") - 1, &ig TSRMLS_CC);
    zend_update_property(alpm_ce_handle, getThis(), "ignorepkgs", sizeof("ignorepkgs") - 1, &ip TSRMLS_CC);
    zend_update_property(alpm_ce_handle, getThis(), "noextracts", sizeof("noextracts") - 1, &ne TSRMLS_CC);
    zend_update_property(alpm_ce_handle, getThis(), "noupgrades", sizeof("noupgrades") - 1, &nu TSRMLS_CC);
}

PHP_METHOD(Handle, add_cachedir) {
    zval _cdlist;
    zval *cdlist;

    char *arg;
    size_t arg_size;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_size) == FAILURE) {
        RETURN_NULL()
    }
    cdlist = zend_read_property(alpm_ce_handle, getThis(), "cachedirs", sizeof("cachedirs") - 1, 0, &_cdlist TSRMLS_DC);
    add_next_index_string(cdlist, arg);
    zend_update_property(alpm_ce_handle, getThis(), "cachedirs", sizeof("cachedirs") - 1, cdlist TSRMLS_CC);

    RETURN_NULL()
}

PHP_METHOD(Handle, add_ignoregrp) {
    zval _grplist;
    zval *grplist;

    char *arg;
    size_t arg_size;

    HANDLE_GETOBJECT()

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_size) == FAILURE) {
        RETURN_NULL()
    }

    grplist = zend_read_property(alpm_ce_handle, getThis(), "ignorepkgs", sizeof("ignorepkgs") - 1, 0, &_grplist TSRMLS_DC);
    add_next_index_string(grplist, arg);
    zend_update_property(alpm_ce_handle, getThis(), "ignorepkgs", sizeof("ignorepkgs") - 1, grplist TSRMLS_CC);

    RETURN_NULL()
}

handle.h

#ifndef PHP_ALPM_HANDLE_H
#define PHP_ALPM_HANDLE_H

#include "php.h"
#include "php_alpm.h"

void alpm_init_handle(TSRMLS_D);

PHP_METHOD(Handle, __construct);

PHP_METHOD(Handle, add_cachedir);
PHP_METHOD(Handle, add_ignoregrp);
PHP_METHOD(Handle, add_ignorepkg);
PHP_METHOD(Handle, add_noextract);
PHP_METHOD(Handle, add_noupgrade);
PHP_METHOD(Handle, get_localdb);
PHP_METHOD(Handle, get_syncdbs);
PHP_METHOD(Handle, init_transaction);
PHP_METHOD(Handle, load_pkg);
PHP_METHOD(Handle, register_syncdb);
PHP_METHOD(Handle, remove_cachedir);
PHP_METHOD(Handle, remove_ignoregrp);
PHP_METHOD(Handle, remove_ignorepkg);
PHP_METHOD(Handle, remove_noextract);
PHP_METHOD(Handle, remove_noupgrade);
PHP_METHOD(Handle, set_pkgreason);

typedef struct _handle_object {
    alpm_errno_t err;
    alpm_handle_t *handle;
    zend_object std;
} handle_object;

static inline handle_object *alpm_handle_from_obj(zend_object *obj) {
    return (handle_object *)((char*)(obj) - XtOffsetOf(handle_object, std));
}

static inline handle_object *Z_HANDLEO_P(zval *zv) {
    return alpm_handle_from_obj(Z_OBJ_P(zv));
}

zend_object *create_handle_struct(zend_class_entry *class TSRMLS_DC);
void free_alpm_handle(void *object TSRMLS_DC);

#endif //PHP_ALPM_HANDLE_H