php-alpm code

db.c

#include "db.h"
#include "handle.h"
#include "util.h"

static zend_object_handlers db_object_handlers;

static zend_function_entry db_methods[] = {
    PHP_ME(Db, __construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)

    PHP_ME(Db, add_server, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, get_grpcache, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, get_name, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, get_pkg, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, get_pkgcache, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, get_servers, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, search,  NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, set_name,  NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, read_grp,  NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, remove_server,  NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Db, update,  NULL, ZEND_ACC_PUBLIC)

    {NULL, NULL, NULL}
};

static void db_free_storage(zend_object *obj TSRMLS_DC) {

}

zend_object *create_db_struct(zend_class_entry *ce TSRMLS_DC) {
    db_object *intern = ecalloc(1, sizeof(db_object) + zend_object_properties_size(ce));

    zend_object_std_init(&intern->std, ce TSRMLS_CC);
    object_properties_init(&intern->std, ce);
    db_object_handlers.offset = XtOffsetOf(db_object, std);
    db_object_handlers.free_obj = db_free_storage;

    intern->std.handlers = &db_object_handlers;

    return &intern->std;
}

void alpm_init_db(TSRMLS_D) {
    zend_class_entry ce;

    INIT_CLASS_ENTRY(ce, "Db", db_methods);
    alpm_ce_db = zend_register_internal_class(&ce TSRMLS_CC);

    ce.create_object = create_db_struct;
}

PHP_METHOD(Db, __construct) {
    zval *handle_obj;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &handle_obj) == FAILURE) {
        RETURN_NULL()
    }

    object_init_ex(return_value, alpm_ce_db);

    db_object *intern = Z_DBO_P(getThis());

    handle_object *h = Z_HANDLEO_P(handle_obj);
    alpm_db_t *db = alpm_get_localdb(h->handle);
    intern->db = db;
}

PHP_METHOD(Db, get_pkg) {
    char *pkgname;
    int *pkgname_int;

    zval *result;

    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &pkgname, &pkgname_int) == FAILURE) {
        RETURN_NULL()
    }

    RETURN_NULL()
}

db.h

#ifndef PHP_ALPM_DB_H
#define PHP_ALPM_DB_H

#include <alpm.h>

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

zend_class_entry *alpm_ce_db;

void alpm_init_db(TSRMLS_D);

PHP_METHOD(Db, __construct);

PHP_METHOD(Db, add_server);
PHP_METHOD(Db, get_grpcache);
PHP_METHOD(Db, get_name);
PHP_METHOD(Db, get_pkg);
PHP_METHOD(Db, get_pkgcache);
PHP_METHOD(Db, get_servers);
PHP_METHOD(Db, search);
PHP_METHOD(Db, set_name);
PHP_METHOD(Db, read_grp);
PHP_METHOD(Db, remove_server);
PHP_METHOD(Db, update);

typedef struct _db_object {
    alpm_db_t *db;

    zend_object std;
} db_object;

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

#define Z_DBO_P(zv) alpm_db_from_obj(Z_OBJ_P(zv))

zend_object *create_db_struct(zend_class_entry *ce TSRMLS_DC);
void free_alpm_db(void *object TSRMLS_DC);

#endif //PHP_ALPM_DB_H

handle.c

#include "handle.h"
#include "db.h"
#include "util.h"

static zend_object_handlers handle_object_handlers;

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_arch,        NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Handle, get_cachedirs,   NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Handle, get_checkspace,  NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Handle, get_ignoregrps,  NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Handle, get_localdb, NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Handle, get_noextracts,  NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Handle, get_noupgrades,  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_arch,        NULL, ZEND_ACC_PUBLIC)
    PHP_ME(Handle, set_checkspace,  NULL, ZEND_ACC_PUBLIC)
//    PHP_ME(Handle, set_pkgreason, NULL, ZEND_ACC_PUBLIC)

    {NULL, NULL, NULL}
};

static void handle_free_storage(zend_object *obj TSRMLS_DC) {

}

zend_object *create_handle_struct(zend_class_entry *class TSRMLS_DC) {
    handle_object *intern = ecalloc(1, sizeof(handle_object) + zend_object_properties_size(class));

    zend_object_std_init(&intern->std, class TSRMLS_CC);
    object_properties_init(&intern->std, class);
    handle_object_handlers.offset = XtOffsetOf(handle_object, std);
    handle_object_handlers.free_obj = handle_free_storage;

    intern->std.handlers = &handle_object_handlers;

    return &intern->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);

    ce.create_object = create_handle_struct;

    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_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_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;

    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);

    handle_object *intern = Z_HANDLEO_P(getThis());

    alpm_errno_t err;
    alpm_handle_t *h = alpm_initialize(rootpath, dbpath, &err);
    intern->handle = h;

    zend_update_property_stringl(alpm_ce_handle, getThis(), "root", sizeof("root") - 1, rootpath, rp TSRMLS_CC);
    zend_update_property_stringl(alpm_ce_handle, getThis(), "dbpath", sizeof("dbpath") - 1, dbpath, dp TSRMLS_CC);
}

PHP_METHOD(Handle, add_cachedir) {
    ADD_METHOD_START()
    alpm_option_add_cachedir(intern->handle, arg);
    RETURN_NULL()
}

PHP_METHOD(Handle, add_ignoregrp) {
    ADD_METHOD_START()
    alpm_option_add_ignoregroup(intern->handle, arg);
    RETURN_NULL()
}

PHP_METHOD(Handle, add_ignorepkg) {
    ADD_METHOD_START()
    alpm_option_add_ignorepkg(intern->handle, arg);
    RETURN_NULL()
}

PHP_METHOD(Handle, add_noextract) {
    ADD_METHOD_START()
    alpm_option_add_noextract(intern->handle, arg);
    RETURN_NULL()
}

PHP_METHOD(Handle, add_noupgrade) {
    ADD_METHOD_START()
    alpm_option_add_noupgrade(intern->handle, arg);
    RETURN_NULL()
}

PHP_METHOD(Handle, get_arch) {
    GETTER_METHOD(alpm_option_get_arch, handle)
}

PHP_METHOD(Handle, get_cachedirs) {
    GET_ARRAY_METHOD(alpm_option_get_cachedirs, handle)
}

PHP_METHOD(Handle, get_checkspace) {
    GETTER_METHOD(alpm_option_get_checkspace, handle)
}

PHP_METHOD(Handle, get_ignoregrps) {
    GET_ARRAY_METHOD(alpm_option_get_ignoregroups, handle)
}

PHP_METHOD(Handle, get_localdb) {
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
        RETURN_NULL()
    }

    zval *db_obj = (zval*)malloc(sizeof(zval));
    handle_object *intern = Z_HANDLEO_P(getThis());

    object_init_ex(db_obj, alpm_ce_db);
}

PHP_METHOD(Handle, get_ignorepkgs) {
    GET_ARRAY_METHOD(alpm_option_get_ignorepkgs, handle)
}

PHP_METHOD(Handle, get_noextracts) {
    GET_ARRAY_METHOD(alpm_option_get_noextracts, handle)
}

PHP_METHOD(Handle, get_noupgrades) {
    GET_ARRAY_METHOD(alpm_option_get_noupgrades, handle)
}

PHP_METHOD(Handle, set_arch) {
    SETTER_METHOD(alpm_option_set_arch, handle)
}

PHP_METHOD(Handle, set_checkspace) {
    SETTER_METHOD(alpm_option_set_checkspace, handle)
}

handle.h

#ifndef PHP_ALPM_HANDLE_H
#define PHP_ALPM_HANDLE_H

#include <alpm.h>

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

zend_class_entry *alpm_ce_handle;

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_arch);
PHP_METHOD(Handle, get_cachedirs);
PHP_METHOD(Handle, get_checkspace);
PHP_METHOD(Handle, get_ignoregrps);
PHP_METHOD(Handle, get_localdb);
PHP_METHOD(Handle, get_noextracts);
PHP_METHOD(Handle, get_noupgrades);
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_arch);
PHP_METHOD(Handle, set_checkspace);
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));
}

#define Z_HANDLEO_P(zv) 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