root/trunk/midgard/apis/php5/midgard.c

/* $Id$
Copyright (C) 2000 The Midgard Project ry
Copyright (C) 2005, 2006, 2007, 2008 Piotr Pokora, <piotrek.pokora@gmail.com>

This program is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include <sys/file.h>
#include "php_midgard.h"
#include "php_midgard_compat.h"
#include <midgard/midgard_http_host.h>

#include "mgd_preparser.h"
#include "mgd_preparse.h"
#include "php_midgard_gobject.h"

#include <zend_exceptions.h>
#include <zend_extensions.h>
#include <zend_ini.h>

#include <locale.h>
#include <SAPI.h>

#ifdef G_LOG_DOMAIN
#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "midgard-core"
#endif

/* True global resources - no need for thread safety here */
static MidgardSchema *midgard_global_schema = NULL;
static zend_class_entry *midgard_metadata_class;
static zend_class_entry *ce_midgard_error_exception;
static MidgardConnection *inherited_cnc;
static void _make_midgard_global();  
guint global_loghandler = 0;
zend_object_handlers php_midgard_gobject_handlers;
/* End of true globals */

static void php_midgard_register_as_zend_extension();

MGD_FUNCTION(ret_type, is_guid, (type_param));

/* Undocumented */
MGD_FUNCTION(ret_type, cache_invalidate, (type_param));
MGD_FUNCTION(ret_type, set_errno, (type_param));

/* Every user visible function must have an entry in midgard_functions[].
*/
function_entry midgard2_functions[] = {
MGD_FE(errno, NULL)
MGD_FE(errstr, NULL)
MGD_FE(version, NULL)
MGD_FE(snippet, NULL)
MGD_FE(preparse, NULL)
MGD_FE(format, NULL)
MGD_FE(template, NULL)
MGD_FE(is_element_loaded, NULL)
MGD_FE(is_guid, NULL)
/* Undocumented */
    {NULL, NULL, NULL}  /* Must be the last line in midgard2_functions[] */
};

gboolean php_midgard_error_throw_exception(MidgardConnection *mgd) 
{
        if(mgd->errnum != MGD_ERR_OK) {
                zend_throw_exception_ex(ce_midgard_error_exception, 
                                0 TSRMLS_CC, mgd->errstr);
                return TRUE;
        }       
        
        return FALSE;
}

/* TODO , Check how msg memory (re)allocation works if msg is passed 
 * to php_error already */
void php_midgard_log_errors(const gchar *domain, GLogLevelFlags level,
                const gchar *msg, gpointer userdata)
{
        MidgardConnection *mgd = (MidgardConnection*) userdata;
        gchar *level_ad = NULL;
        guint mlevel = midgard_connection_get_loglevel(mgd);

        g_assert(msg != NULL);

        switch (level) {
                case G_LOG_FLAG_RECURSION:
                        level_ad =  "RECURSION";
                        break;
                        
                case G_LOG_FLAG_FATAL:
                        level_ad = "FATAL! ";
                        break;
                        
                case G_LOG_LEVEL_ERROR:
                        level_ad =  "ERROR";
                        php_error(E_ERROR,
                                        "(pid:%ld): %s",
                                        (unsigned long)getpid(), msg);
                        return;
                        break;
                        
                case G_LOG_LEVEL_CRITICAL:
                        level_ad = "CRITICAL ";
                        php_error(E_WARNING,
                                        "(pid:%ld): %s",
                                        (unsigned long)getpid(), msg);
                        return;
                        break;
                        
                case G_LOG_LEVEL_WARNING: 
                        level_ad =  "WARNING";  
                        php_error(E_WARNING,
                                        "(pid:%ld): %s",
                                        (unsigned long)getpid(), msg);                                  
                        return;
                        break;
                        
                case G_LOG_LEVEL_MESSAGE:
                        level_ad = "MESSAGE";
                        break;
                
                case G_LOG_LEVEL_INFO:
                        level_ad = "info";      
                        break;
                        
                case G_LOG_LEVEL_DEBUG:
                        level_ad = "DEBUG";     
                        break;
                        
                default:
                        level_ad =  "Unknown level";
                        break;
        }       

        if (mlevel >= level) {
        
                midgard_error_default_log(
                                domain, level, msg, MIDGARD_CONNECTION(mgd_handle()));
        }
}

ZEND_DECLARE_MODULE_GLOBALS(midgard2) 

zend_module_entry midgard2_module_entry = {
        STANDARD_MODULE_HEADER,
        "midgard2",
        midgard2_functions,
        PHP_MINIT(midgard2),
        PHP_MSHUTDOWN(midgard2),
        PHP_RINIT(midgard2),    
        PHP_RSHUTDOWN(midgard2), 
        PHP_MINFO(midgard2),
        MIDGARD_LIB_VERSION,          /* extension version number (string) */
        STANDARD_MODULE_PROPERTIES
};

//#ifdef COMPILE_DL_MIDGARD2
ZEND_GET_MODULE(midgard2)
//#endif

ZEND_INI_BEGIN()
ZEND_INI_ENTRY("midgard.configuration", "", ZEND_INI_SYSTEM, NULL)
ZEND_INI_ENTRY("midgard.http", "Off", ZEND_INI_SYSTEM, NULL)
ZEND_INI_ENTRY("midgard.engine", "On", ZEND_INI_ALL, NULL)
ZEND_INI_ENTRY("midgard.quota", "Off", ZEND_INI_ALL, NULL)
ZEND_INI_ENTRY("midgard.memory_debug", "Off", ZEND_INI_ALL, NULL)
ZEND_INI_END()

static void php_midgard2_init_globals(zend_midgard2_globals *midgard2_globals)
{
        midgard2_globals->mgd = NULL;
}

static gboolean php_midgard_ini_enabled(const gchar *ini_entry)
{
        g_assert(ini_entry != NULL);

        gchar *entry = zend_ini_string((gchar *)ini_entry, strlen(ini_entry)+1, 0);
        gchar *lentry = g_ascii_strdown(entry, strlen(entry));

        gboolean enabled = FALSE;

        /* Kind of weird, zend_ini_entry returns 'Off' but might returns '1' when set to 'On' */
        if(g_str_equal(lentry, "on")
                        || *lentry == '1')
                enabled = TRUE;

        g_free(lentry);

        return enabled;
}

static gboolean php_midgard_memory_debug()
{
        return php_midgard_ini_enabled("midgard.memory_debug");
}

static gboolean php_midgard_engine_is_enabled()
{
        gchar *engine = zend_ini_string("midgard.engine", sizeof("midgard.engine"), 0);
        gchar *lengine = g_ascii_strdown(engine, strlen(engine));

        gboolean enabled = FALSE;
        
        if(g_str_equal(lengine, "on"))
                enabled = TRUE;

        g_free(lengine);

        return enabled;
}

static gboolean php_midgard_is_http_env()
{
        gchar *http = zend_ini_string("midgard.http", sizeof("midgard.http"), 0);
        gchar *lhttp = g_ascii_strdown(http, strlen(http));

        gboolean enabled = FALSE;
        
        if(g_str_equal(lhttp, "on"))
                enabled = TRUE;

        g_free(lhttp);

        return enabled;
}

static const gchar *php_midgard_get_configuration()
{
        gchar *config = zend_ini_string("midgard.configuration", sizeof("midgard.configuration"), 0);
        return (const gchar *) config;
}

static GHashTable *all_configs = NULL;

static gboolean php_midgard_initialize_configs()
{
        if(all_configs != NULL)
                return TRUE;

        all_configs = midgard_connection_open_all(FALSE);

        if(all_configs != NULL)
                return TRUE;

        return FALSE;
}

PHP_MINIT_FUNCTION(midgard2)
{
        zend_extension *ze = zend_get_extension("midgard");
        if(ze != NULL) {
                php_error(E_ERROR, "Module midgard (1.x) already loaded");
                return FAILURE; 
        }

        ze = zend_get_extension(MIDGARD_PACKAGE_NAME);
        if(ze != NULL) {
                php_error(E_NOTICE, "Module midgard2 already loaded. It's recommended to load it via php.ini");
                return SUCCESS;
        } 

        /*
        zend_module_entry *module;
        int rv = zend_hash_find(&module_registry, "midgard2", strlen("midgard2")+1, (void**)&module);
        if(rv == SUCCESS) 
                return SUCCESS;
        */

        global_loghandler = 
                g_log_set_handler("midgard-core", G_LOG_LEVEL_MASK,
                                midgard_error_default_log, NULL);
                
        //g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL);
        //g_log_set_fatal_mask("GLib-GObject", G_LOG_LEVEL_CRITICAL);

        ZEND_INIT_MODULE_GLOBALS(midgard2, php_midgard2_init_globals, NULL);

        zend_register_auto_global("_MIDGARD", sizeof("_MIDGARD")-1, NULL TSRMLS_CC);
        zend_register_auto_global("_MIDCOM", sizeof("_MIDCOM")-1, NULL  TSRMLS_CC);
        zend_register_auto_global("_MIDGARD_CONNECTION", sizeof("_MIDGARD_CONNECTION")-1, NULL  TSRMLS_CC);

        midgard_init();

        /* register Gtype types from schemas */
        if(!g_type_from_name("midgard_article") 
                        && midgard_global_schema == NULL) {

                midgard_global_schema = g_object_new(MIDGARD_TYPE_SCHEMA, NULL);
                midgard_schema_init((MidgardSchema *) midgard_global_schema);
                midgard_schema_read_dir((MidgardSchema *) midgard_global_schema, MIDGARD_LSCHEMA_DIR);
        }

        /* Initialize handlers */
        memcpy(&php_midgard_gobject_handlers,
                        zend_get_std_object_handlers(), sizeof(zend_object_handlers));
        /* Custom handlers hooks */
        php_midgard_gobject_handlers.clone_obj = NULL;
        php_midgard_gobject_handlers.read_property = php_midgard_gobject_read_property;
        php_midgard_gobject_handlers.write_property = php_midgard_gobject_write_property;
        php_midgard_gobject_handlers.get_properties = php_midgard_zendobject_get_properties;
        php_midgard_gobject_handlers.has_property = php_midgard_gobject_has_property;

        /* Register midgard_exception class */
        zend_class_entry ce;
        INIT_CLASS_ENTRY(ce, "midgard_error_exception", NULL);
        ce_midgard_error_exception = zend_register_internal_class_ex(&ce,
                        zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);

        php_midgard_reflection_property_init(module_number);
        php_midgard_query_builder_init(module_number);
        php_midgard_config_init(module_number);
        php_midgard_user_init(module_number);
        php_midgard_blob_init(module_number);
        php_midgard_sitegroup_init(module_number);
        php_midgard_object_class_init(module_number);
        php_midgard_request_config_init(module_number);
        php_midgard_collector_init(module_number);
        php_midgard_connection_init(module_number);
        php_midgard_object_init(module_number);
        php_midgard_dbus_init(module_number);
        php_midgard_replicator_init(module_number);

        /* Register midgard_metadata class */
        static zend_class_entry midgard_metadata_class_entry;
        INIT_CLASS_ENTRY(midgard_metadata_class_entry, "midgard_metadata", NULL);
        midgard_metadata_class = zend_register_internal_class(&midgard_metadata_class_entry TSRMLS_CC);
        
        /* Register properties' midgard types */
        REGISTER_LONG_CONSTANT("MGD_TYPE_NONE", MGD_TYPE_NONE, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_TYPE_STRING", MGD_TYPE_STRING, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_TYPE_INT", MGD_TYPE_INT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_TYPE_UINT", MGD_TYPE_UINT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_TYPE_FLOAT", MGD_TYPE_FLOAT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_TYPE_BOOLEAN", MGD_TYPE_BOOLEAN, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_TYPE_TIMESTAMP", MGD_TYPE_TIMESTAMP, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_TYPE_LONGTEXT", MGD_TYPE_LONGTEXT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_TYPE_GUID", MGD_TYPE_GUID, CONST_CS | CONST_PERSISTENT);
        
        /* Register errcode constants */
        REGISTER_LONG_CONSTANT("MGD_ERR_OK", MGD_ERR_OK, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_ERROR", MGD_ERR_ERROR, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_ACCESS_DENIED", MGD_ERR_ACCESS_DENIED, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_SITEGROUP_VIOLATION", MGD_ERR_SITEGROUP_VIOLATION, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_NOT_OBJECT", MGD_ERR_NOT_OBJECT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_INVALID_NAME", MGD_ERR_INVALID_NAME, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_DUPLICATE", MGD_ERR_DUPLICATE, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_HAS_DEPENDANTS", MGD_ERR_HAS_DEPENDANTS, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_RANGE", MGD_ERR_RANGE, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_NOT_CONNECTED", MGD_ERR_NOT_CONNECTED, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_SG_NOTFOUND", MGD_ERR_SG_NOTFOUND, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_INVALID_OBJECT", MGD_ERR_INVALID_OBJECT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_QUOTA", MGD_ERR_QUOTA, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_INTERNAL", MGD_ERR_INTERNAL, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_OBJECT_NAME_EXISTS", MGD_ERR_OBJECT_NAME_EXISTS, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_OBJECT_NO_STORAGE", MGD_ERR_OBJECT_NO_STORAGE, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_OBJECT_PARENT", MGD_ERR_OBJECT_NO_PARENT, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_INVALID_PROPERTY_VALUE", MGD_ERR_INVALID_PROPERTY_VALUE, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_INVALID_PROPERTY", MGD_ERR_INVALID_PROPERTY, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_USER_DATA", MGD_ERR_USER_DATA, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_OBJECT_DELETED", MGD_ERR_OBJECT_DELETED, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_OBJECT_PURGED", MGD_ERR_OBJECT_PURGED, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_OBJECT_EXPORTED", MGD_ERR_OBJECT_EXPORTED, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_OBJECT_IMPORTED", MGD_ERR_OBJECT_IMPORTED, CONST_CS | CONST_PERSISTENT);
        REGISTER_LONG_CONSTANT("MGD_ERR_MISSED_DEPENDENCE", MGD_ERR_MISSED_DEPENDENCE, CONST_CS | CONST_PERSISTENT);
        
        REGISTER_INI_ENTRIES();

        /* midgard.http is on so we make all available connections */
        if (php_midgard_is_http_env()) {
        
                g_debug("Found server context. Initialize all configurations");
                if(!php_midgard_initialize_configs())
                        return FAILURE;
        }

        /* Register midgard as Zend extension */
        php_midgard_register_as_zend_extension();

        return SUCCESS;
}

static void __free_connections(gpointer key, gpointer val, gpointer ud)
{
        MidgardConnection *cnc = MIDGARD_CONNECTION(val);
        g_object_unref(cnc);
}

PHP_MSHUTDOWN_FUNCTION(midgard2)
{       
        //g_warning("MIDGARD MODULE SHUTDOWN - FIXME");
        return SUCCESS;

        UNREGISTER_INI_ENTRIES();

        /* Free schema */
        if(midgard_global_schema != NULL)
                g_object_unref(midgard_global_schema);

        /* Free connections */
        if(all_configs != NULL) {
                
                g_hash_table_foreach(all_configs, __free_connections, NULL);
                
        } else {
                
                MidgardConnection *mgd = mgd_handle();
                if(mgd != NULL) 
                        g_object_unref(mgd);
        }

        return SUCCESS;
}

static const gchar *php_midgard_get_request_uri()
{
        /* FIXME */
        /* In theory we should get request_uri string from SG(request_info).request_uri, 
         * but it holds SCRIPT_NAME name when RINIT is invoked. 
         * Hash lookup is acceptable, but it would be better to get uri directly.*/

        zval **data;
        
        if(zend_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]),
                                "REQUEST_URI", sizeof("REQUEST_URI"), (void **) &data) == FAILURE)
                return NULL;

        return (const gchar *)Z_STRVAL_PP(data);
}

static const gchar *php_midgard_get_request_host()
{
        zval **data;

        if(zend_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]),
                                "HTTP_HOST", sizeof("HTTP_HOST"), (void **) &data) == FAILURE)
                return NULL;

        return (const gchar *)Z_STRVAL_PP(data);
}

static MidgardHttpHost *global_http_host = NULL;

static void php_midgard_initialize_http_request()
{       
        const gchar *uri = php_midgard_get_request_uri();

        if(uri == NULL){
                g_warning("NULL uri in server context");
                return;
        }

        const gchar *hoststr = php_midgard_get_request_host();

        if(hoststr == NULL) {
                g_warning("NULL hostname in server context");
                return;
        }

        gchar **hostsd = g_strsplit(hoststr, ":", -1);

        MidgardHttpHost *http_host =
                midgard_http_host_new(mgd_handle(), hostsd[0], atoi(hostsd[1]), uri);

        g_strfreev(hostsd);

        if(http_host == NULL)
                return;

        global_http_host = http_host;

        MidgardRequestConfig *rcfg = midgard_http_host_get_request_config(http_host);
        if(!midgard_connection_set_request_config(mgd_handle(), rcfg))
                g_warning("Couldn't set request configuration for current connection");

        return;
}

PHP_RINIT_FUNCTION(midgard2)
{       
        inherited_cnc = NULL;

        if(!php_midgard_engine_is_enabled())
                return SUCCESS;

        if (SG(server_context)) {       

                const gchar *config = php_midgard_get_configuration();
                MidgardConnection *cnc = 
                        (MidgardConnection *) g_hash_table_lookup(all_configs, config);
        
                /* Try to connect */
                if(cnc == NULL) {
                        
                        g_warning("Can not find connection handler for '%s' configuration", config);
                        return FAILURE;
                }

                g_debug("Found connection handler for '%s'", config);   
                MGDG(mgd) = midgard_connection_copy(cnc);
                inherited_cnc = cnc;
        }

        if(MGDG(mgd) != NULL) {

                guint loghandler = 
                        g_log_set_handler(G_LOG_DOMAIN, 
                                        G_LOG_LEVEL_MASK,
                                        php_midgard_log_errors, 
                                        (gpointer)mgd_handle());
                midgard_connection_set_loghandler(mgd_handle(), loghandler);

                inherited_cnc = mgd_handle();

                /* Initialize _MIDGARD_CONNECTION singleton */
                zval *_mcg = NULL;
                MAKE_STD_ZVAL(_mcg);
                php_midgard_gobject_init(_mcg, "midgard_connection", 
                                G_OBJECT(mgd_handle()), FALSE);
                /* PHP object constructor hack.
                 * I have no idea how to "trigger" php constructor here */
                /* TODO, check object_init_ex and similiar */
                zend_hash_add(&EG(symbol_table), "_MIDGARD_CONNECTION",
                                sizeof("_MIDGARD_CONNECTION"),
                                &_mcg, sizeof(zval **), NULL);

        }

        if (SG(server_context)) {
                php_midgard_initialize_http_request();
        }

        _make_midgard_global();

         /* Initialize closure hash */
        php_midgard_gobject_closure_hash_new();

        return SUCCESS; 
}

PHP_RSHUTDOWN_FUNCTION(midgard2)
{       
        MidgardConnection *mgd = mgd_handle();
        
        g_debug("RSHUTDOWN");

        if(mgd != NULL){ 

        
                /* FIXME , replace with MidgardConnection API */
                if(mgd->person){
                        g_object_unref(G_OBJECT(mgd->person));
                        /* Set NULL explicitly. It work very fine with php-cli 
                         * however NULL must be set for Apache "sub"requests */
                        mgd->person = NULL;
                }

                mgd->rcfg = NULL; /* REMOVE ME */
        }

        if(inherited_cnc != NULL) {
                
                /* Remove G_LOG_DOMAIN loghandler!
                 * Apache module or any other application might need to assign
                 * own loghandler for midgard-core domain between RSHUTDOWN and RINIT */

                g_log_remove_handler(G_LOG_DOMAIN,
                                midgard_connection_get_loghandler(inherited_cnc));

                g_object_unref(inherited_cnc);
                inherited_cnc = NULL;
        }

        if(global_http_host != NULL)
                g_object_unref(global_http_host);

        /* Free all closures 
         * We can not keep them persistant as all data changes per request. */
        php_midgard_gobject_closure_hash_free();

        /*
        zend_extension *ze = zend_get_extension(MIDGARD_PACKAGE_NAME);
        if(ze) {
                g_warning("Found midgard extension with handle %d", (int)ze->handle);
                ze->handle = 0;
        }*/
        
        /* It's not safe, but allow valgrind to print function names.
         * It simply forces Zend to not unload midgard module */
        zend_module_entry *module;
        int rv = zend_hash_find(&module_registry, "midgard2", strlen("midgard2")+1, (void**)&module);

        if(rv == SUCCESS) {
                if(php_midgard_memory_debug()) {
                        mgd_info("DISABLE MODULE HANDLE");
                        module->handle = 0;
                }
        }

        g_debug("MIDGARD RSHUTDOWN SUCCESS");
        return SUCCESS;
}

PHP_MINFO_FUNCTION(midgard2)
{
    int i = 0;
    php_info_print_table_start();
    php_info_print_table_header(2, "Midgard2 Support", "enabled");
    php_info_print_table_row(2, "Midgard2 version", midgard_version());
    
    while (midgard2_module_entry.functions[i].fname) {
        php_info_print_table_row(2, "", midgard2_module_entry.functions[i].fname);
        i++;
    }
    php_info_print_table_end();

    i = 0;
    php_info_print_table_start();
    php_info_print_table_header(2, "MgdSchema technology support", "enabled");
    php_info_print_table_row(2, "Midgard2 version", midgard_version());

    /* 
    while (__midgard_php_type_functions[i].fname) {
        php_info_print_table_row(2, "", __midgard_php_type_functions[i].fname);
        i++;
    }
    */
    php_info_print_table_end();
        
    php_info_print_box_start(0);
    PUTS("<h3><a href=\"http://www.midgard-project.org/\">");
    PUTS("The Midgard Project</a></h3>\n");

    php_printf("This program makes use of the Midgard Content Management engine:<br />");
    php_printf("&copy; 1998-2001 The Midgard Project Ry - 2000-2001 Aurora Linux<br />\n");
    php_printf("&copy; 2002-2008 The Midgard Community<br />\n");
    php_info_print_box_end();

    /* Remove comments if you have entries in php.ini
    DISPLAY_INI_ENTRIES();
    */
}

MGD_FUNCTION(ret_type, config_init, (type_param))
{
        gchar *conf;
        gint conf_length;
        MidgardConnection *mgd;
        RETVAL_FALSE;

        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
                                &conf, &conf_length) == FAILURE)
                return;

        /* Check if connection is established */
        if(mgd_handle() != NULL) {
                
                php_error(E_NOTICE, 
                                "mgd_config_init is deprecated. Use midgard_connection class");
                RETURN_TRUE;
        }
        
        /* TODO , open connection here if really needed for some backward compatibility */      
}

/* Fetch static globals. Unfortunately these need to be here since the
   module globals are declared static by the Zend macros
*/
MidgardConnection *mgd_handle()
{
        TSRMLS_FETCH();
        return MGDG(mgd);
}

void mgd_handle_set(MidgardConnection *mgd)
{
        g_assert(mgd != NULL);

        TSRMLS_FETCH();
        MGDG(mgd) = mgd;
}

void mgd_set_errno(MgdErrorGeneric mgd_errno)
{
        TSRMLS_FETCH();
        MIDGARD_ERRNO_SET(mgd_handle(), mgd_errno);  
}

void mgd_reset_errno(void)
{
        TSRMLS_FETCH();
        MIDGARD_ERRNO_SET(mgd_handle(), MGD_ERR_OK);
}

int mgd_get_errno()
{
        TSRMLS_FETCH();
        return mgd_handle()->errnum;
}

MGD_FUNCTION(ret_type, get_midgard, (type param))
{
        /* TODO, rewrite me */
        /* Get data from $MIDGARD */
}

MGD_FUNCTION(ret_type, set_default_lang, (type_param))
{
        CHECK_MGD;
        RETVAL_FALSE;
        guint lang;

        if (zend_parse_parameters(1 TSRMLS_CC, "l", &lang)
                        == FAILURE) {
                WRONG_PARAM_COUNT;
        }

        /* mgd_set_default_lang(mgd_handle(), lang); */
        RETVAL_TRUE;
}

MGD_FUNCTION(ret_type, get_default_lang, (type_param))
{
        CHECK_MGD;
        RETVAL_FALSE;

        if(ZEND_NUM_ARGS() > 0)
                WRONG_PARAM_COUNT;

        RETVAL_TRUE;
        /*RETURN_LONG(mgd_get_default_lang(mgd_handle()));*/
}

static void _make_midgard_global()
{       
        int i;  
        zval *types, *confv, *mgd_php_globals, *schema_array;
        MidgardConnection *mgd = mgd_handle();
        MidgardRequestConfig *rcfg = NULL;
        GValueArray *array = NULL;

        if(mgd != NULL)
                rcfg = mgd->rcfg;

        TSRMLS_FETCH(); 
        
        /* Initialize _MIDGARD array keys */
        MAKE_STD_ZVAL(mgd_php_globals);
        array_init(mgd_php_globals);

        /* Initialize schema classes array */
        MAKE_STD_ZVAL(schema_array);
        array_init(schema_array);
        
        MAKE_STD_ZVAL(types);
        array_init(types);
        
        guint n_types;
        GType *all_types = g_type_children(MIDGARD_TYPE_OBJECT, &n_types);
        
        for (i = 0; i < n_types; i++) {
        
                add_assoc_string(types, 
                                (gchar *)g_type_name(all_types[i]), "", 1);
        }

        i = 0;

        add_assoc_zval(schema_array, "types", types);
        g_free(all_types);

        add_assoc_zval(mgd_php_globals, "schema", schema_array);

        zval *mro = NULL;
        MAKE_STD_ZVAL(mro);     

        /* This can be cli ? */
        if(rcfg == NULL) {

                //MidgardRequest *request = midgard_request_new();
                //php_midgard_gobject_init(mro, "midgard_request", G_OBJECT(request), TRUE);
                //add_assoc_zval(mgd_php_globals, "midgard_request", mro);
        }

        /* Data from MidgardRequest */
        if(rcfg != NULL) {

                /* MIDGARD_REQUEST */
                php_midgard_gobject_init(mro, "midgard_request_config", G_OBJECT(rcfg), TRUE);
                //add_assoc_zval(mgd_php_globals, "midgard_request", mro);
                
                /* ARGC */
                add_assoc_long(mgd_php_globals, "argc", rcfg->argc);

                /* ARGV */
                zval *argv;
                MAKE_STD_ZVAL(argv);
                array_init(argv);

                if(rcfg->argv != NULL) {
                        
                        array = (GValueArray *) rcfg->argv;
                        
                        for (i = 0; i < array->n_values; i++) {
                                
                                GValue *strval = g_value_array_get_nth(array, i);
                                const gchar *argvstr = 
                                        g_value_get_string((const GValue *)strval);
                                add_index_string(argv, i, (gchar *)argvstr, 1);
                        }

                        array = NULL;
                }
                add_assoc_zval(mgd_php_globals, "argv", argv);

                /* URI */
                add_assoc_string(mgd_php_globals, "uri", rcfg->uri, 1);

                /* SELF */
                add_assoc_string(mgd_php_globals, "self", rcfg->uri, 1);

                /* LANG */
                add_assoc_long(mgd_php_globals, "lang",
                                midgard_connection_get_lang_id(mgd, NULL));

                /* SITEGROUP */
                add_assoc_long(mgd_php_globals, "sitegroup",
                                midgard_connection_get_sitegroup_id(mgd));

                guint id = 0;
                /* PAGE ID */
                if(rcfg->page)  
                        g_object_get(G_OBJECT(rcfg->page), "id", &id, NULL);
                        
                add_assoc_long(mgd_php_globals, "page", id);
                

                /* HOST ID */
                id = 0;
                if(rcfg->host) {
                        g_object_get(G_OBJECT(rcfg->host), "id", &id, NULL);
                        /* FIXME , Initialize midgard_host for PHP */
                }
        
                add_assoc_long(mgd_php_globals, "host", id);

                /* AUTH */
                add_assoc_bool(mgd_php_globals, "auth", rcfg->auth_required);

                /* STYLE */
                id = 0;
                if(rcfg->style)
                        g_object_get(G_OBJECT(rcfg->style), "id", &id, NULL);
                add_assoc_long(mgd_php_globals, "style", id);
                
        }

        /* configure prefix */
        MAKE_STD_ZVAL(confv);
        array_init(confv);
        add_assoc_string(confv, "prefix", MIDGARD_LIB_PREFIX, 1);
        add_assoc_zval(mgd_php_globals, "config", confv);

        zend_hash_update(&EG(symbol_table), "_MIDGARD", 
                        sizeof("_MIDGARD"), &mgd_php_globals, 
                        sizeof(zval *), NULL);
}


/* Piotras: zend_parse_parameters_ex with first 'quiet' parameter
 * is used to return false without any warning being set on PHP level.
 * This is midcom related. 
 * I define quiet parameter as 2 , in any other case it's not quiet.
 * I have no idea if it's hack like, but it works as expected */
MGD_FUNCTION(ret_type, is_guid, (type param))
{
        gchar *guid;
        guint guidl;
        CHECK_MGD;