xoonips/AL/xnpal.cc

/*
        VPAL: Visiome Platform Abstract Layer
        
        zend_parse_parameters縺ｯphp4.1.0縺悟ｿ?ｦ?/span>
        .so繝輔ぃ繧､繝ｫ縺ｯ螟悶°繧芽ｦ九∴縺ｪ縺??ｴ謇?縺ｫ鄂ｮ縺上∋縺阪??/span>
        C++縺ｧ縺ｯ縲‘xtern "C"{}, BEGIN/END_EXTERN_C()縺悟ｿ?ｦ√??/span>
*/


#include <stdio.h>
#include "criteria.h"
#include "common.h"
#include "commonal.h"
#include "session.h"
#include "group.h"
#include "account.h"
#include "vpal.h"

// for inet_aton
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

// global variables
MYSQL *mysql = NULL;


/* declaration of functions to be exported */
extern "C" {
ZEND_FUNCTION(first_module         );
ZEND_FUNCTION(vp_initialize_db     );
ZEND_FUNCTION(vp_login_user        );
ZEND_FUNCTION(vp_logout_user       );
ZEND_FUNCTION(vp_create_session    );
ZEND_FUNCTION(vp_get_session       );
ZEND_FUNCTION(vp_is_activated      );
ZEND_FUNCTION(vp_activate          );
ZEND_FUNCTION(vp_get_account_count );
ZEND_FUNCTION(vp_delete_account    );
ZEND_FUNCTION(vp_get_account       );
ZEND_FUNCTION(vp_get_accounts      );
ZEND_FUNCTION(vp_insert_account    );
ZEND_FUNCTION(vp_update_account    );
ZEND_FUNCTION(vp_dump_uids         );
ZEND_FUNCTION(vp_get_group_count   );
ZEND_FUNCTION(vp_get_groups_by_uid );
ZEND_FUNCTION(vp_is_group_admin    );
ZEND_FUNCTION(vp_dump_gids         );
/*
ZEND_FUNCTION(vp_dump_group_admins );
ZEND_FUNCTION(vp_delete_member     );
ZEND_FUNCTION(vp_insert_member     );
ZEND_FUNCTION(vp_get_members       );
ZEND_FUNCTION(vp_delete_group      );
ZEND_FUNCTION(vp_insert_group      );
ZEND_FUNCTION(vp_update_group      );
ZEND_FUNCTION(vp_get_group         );
ZEND_FUNCTION(vp_get_groups        );
ZEND_FUNCTION(vp_is_moderator      );
ZEND_FUNCTION(vp_get_uid           );
*/

ZEND_FUNCTION(vp_test_criteria     );
ZEND_FUNCTION(vp_test_uids         );
};
/* compiled function list so Zend knows what's in this module */
zend_function_entry vpalmod_functions[] =
{
    ZEND_FE(first_module         ,NULL)
    ZEND_FE(vp_initialize_db     ,NULL)
    ZEND_FE(vp_login_user        ,NULL)
    ZEND_FE(vp_logout_user       ,NULL)
    ZEND_FE(vp_create_session    ,NULL)
    ZEND_FE(vp_get_session       ,NULL)
    ZEND_FE(vp_is_activated      ,NULL)
    ZEND_FE(vp_activate          ,NULL)
    ZEND_FE(vp_get_account_count ,NULL)
    ZEND_FE(vp_delete_account    ,NULL)
    ZEND_FE(vp_get_account       ,NULL)
    ZEND_FE(vp_get_accounts      ,NULL)
    ZEND_FE(vp_insert_account    ,NULL)
    ZEND_FE(vp_update_account    ,NULL)
    ZEND_FE(vp_dump_uids         ,NULL)
    ZEND_FE(vp_get_group_count   ,NULL)
    ZEND_FE(vp_get_groups_by_uid ,NULL)
    ZEND_FE(vp_is_group_admin    ,NULL)
    ZEND_FE(vp_dump_gids         ,NULL)
/*
    ZEND_FE(vp_dump_group_admins ,NULL)
    ZEND_FE(vp_delete_member     ,NULL)
    ZEND_FE(vp_insert_member     ,NULL)
    ZEND_FE(vp_get_members       ,NULL)
    ZEND_FE(vp_delete_group      ,NULL)
    ZEND_FE(vp_insert_group      ,NULL)
    ZEND_FE(vp_update_group      ,NULL)
    ZEND_FE(vp_get_group         ,NULL)
    ZEND_FE(vp_get_groups        ,NULL)
    ZEND_FE(vp_is_moderator      ,NULL)
    ZEND_FE(vp_get_uid           ,NULL)
*/    
    ZEND_FE(vp_test_criteria     ,NULL)
    ZEND_FE(vp_test_uids         ,NULL)
    {NULL, NULL, NULL}
};

/* compiled module information */
zend_module_entry vpalmod_module_entry =
{
    STANDARD_MODULE_HEADER,
    "Visiome Platform Abstract Layer",
    vpalmod_functions,
    NULL, 
    NULL, 
    NULL, 
    NULL, 
    NULL,
    NO_VERSION_YET,
    STANDARD_MODULE_PROPERTIES
};

/* implement standard "stub" routine to introduce ourselves to Zend */
#if COMPILE_DL_FIRST_MODULE
BEGIN_EXTERN_C()
ZEND_GET_MODULE(vpalmod)
END_EXTERN_C()
#endif

/* implement function that is meant to be made available to PHP */
ZEND_FUNCTION(first_module)
{
    long parameter;
//      if(ZEND_NUM_ARGS() != 2) WRONG_PARAM_COUNT;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &parameter) == FAILURE) {
        return;
    }
        parameter++;
    RETURN_LONG(parameter);
}
/** zval縺九ｉC縺ｮ譁?ｭ怜?繧貞ｾ励ｋ縲?/span>
  */
char *getZvalString( zval **p ){
        convert_to_string_ex(p);
        return Z_STRVAL_PP(p); //(**p).value.str.val;
}

/** zval縺九ｉint繧貞ｾ励ｋ縲?/span>
  */
int getZvalInt( zval **p ){
        convert_to_long_ex(p);
        return Z_LVAL_PP(p); // (int)(**p).value.lval;
}

// keylen縺ｯ譛ｫ蟆ｾ縺ｮ\0繧貞性繧?縲?/span>
static void print_hash_key( int res, const char *key, uint keyLen, ulong index ){
        zend_printf( "print_hash_key : key=0x%08x keylen=%08d index=%08d<br>  ", key, keyLen, index );
        if ( res == HASH_KEY_IS_STRING ){
                char *p = new char[keyLen+1];
                memcpy( p, key, keyLen );
                p[keyLen] = 0;
                zend_printf( "  key is string[%s]<br>\n", p );
        }
        else {
                zend_printf( "  key is integer[%d]<br>\n", index );
        }
}


/** zval**縺九ｉcriteria_t繧堤函謌舌☆繧九◆繧√?繧ｯ繝ｩ繧ｹ縲ら函謌仙､ｱ謨励↑繧曳etResult()!=RES_OK
  * criteria : 
    array( 'start'=>0, 'rows'=>10, 
       'orders'=>array(
        array('name'=>'id','order'=>'0'),
        array('name'=>'timestamp','name'=>'1'), ...)
    ); 縺薙ｓ縺ｪ蠖｢縺ｮ騾｣諠ｳ驟榊?
  */
class zCriteria_t : public criteria {
private:
        result_t result;
public:
        // pz: array('name'=>'timestamp','name'=>'1')
        // 縺薙ｌ縺九ｉorderby繧剃ｽ懈?縺励※霑ｽ蜉?縲?/span>
        void setOrder( zval *pz ){
                char *column = 0;
                order_t order = (order_t)0;
                
                HashPosition pos;
                zval **ppzTmp = 0;
                int res2;
                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
                while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
                        char *key = 0;
                        uint keyLen = 0;
                        ulong index = 0;
                        int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
                        if ( keyType == HASH_KEY_IS_STRING/*1*/ ||  keyType == HASH_KEY_IS_LONG/*2*/ ){
                                print_hash_key( keyType, key, keyLen, index );
                                if ( strncasecmp( key, "column", keyLen ) == 0 && keyLen == 7 ){
                                        SEPARATE_ZVAL(ppzTmp);
                                        column = getZvalString(ppzTmp);
//                                      zend_printf( "column=%s<br>\n", column );
                                }
                                else if ( strncasecmp( key, "order", keyLen ) == 0 && keyLen == 6 ){
                                        SEPARATE_ZVAL(ppzTmp);
                                        order = (order_t)getZvalInt(ppzTmp);
//                                      zend_printf( "order=%d<br>\n", order );
                                }
                        }
                        
                        zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
                }
                if ( column ){
                        orderby *o = new orderby( column, order );
                        addOrderBy( o );
                }
                
                result = RES_OK;
        }
        
        // pz: array( array('column'=>'hoge','order'=>'1'), array('column'=>'huga','order'=>'2'), ...)
        void setOrders( zval *pz ){
                HashPosition pos;
                
                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
                
                zval **ppzTmp = 0;
                int res2;
                while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
                        char *key = 0;
                        uint keyLen = 0;
                        ulong index = 0;
                        int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
                        if ( keyType == HASH_KEY_IS_STRING/*1*/ ||  keyType == HASH_KEY_IS_LONG/*2*/ ){
                                print_hash_key( keyType, key, keyLen, index );
                                setOrder( *ppzTmp );
                        }
                        zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
                }
                result = RES_OK;
        }
        
        void initialize( zval *pz ){
                HashPosition pos;
                zval **ppzTmp = 0;
                int res2;
                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pz), &pos);
                while ( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(pz), (void **)&ppzTmp, &pos)) == SUCCESS ) {
                        char *key = 0;
                        uint keyLen = 0;
                        ulong index = 0;
                        int keyType = zend_hash_get_current_key_ex(Z_ARRVAL_P(pz), &key, &keyLen, &index, false/*duplicate flag*/, &pos );
                        if ( keyType == HASH_KEY_IS_STRING/*1*/ ||  keyType == HASH_KEY_IS_LONG/*2*/ ){
                                print_hash_key( keyType, key, keyLen, index );
                                if ( strncasecmp( key, "start", keyLen ) == 0 && keyLen == 6 ){
                                        SEPARATE_ZVAL(ppzTmp);
                                        int tmp = getZvalInt(ppzTmp);
//                                      zend_printf( "start=%d<br>\n", tmp );
                                        setLimit( tmp, getLimitRows() );
                                }
                                else if ( strncasecmp( key, "rows", keyLen ) == 0 && keyLen == 5 ){
                                        SEPARATE_ZVAL(ppzTmp);
                                        int tmp = getZvalInt(ppzTmp);
//                                      zend_printf( "rows=%d<br>\n", tmp );
                                        setLimit( getLimitStart(), tmp );
                                }
                                else if ( strncasecmp( key, "orders", keyLen ) == 0 && keyLen == 7 ){
                                        setOrders( *ppzTmp );
                                }
                                else
                                        ;       // ignore unknown key
                        }
                        else
                                ; // ignore bad key
                        zend_hash_move_forward_ex(Z_ARRVAL_P(pz), &pos);
                }
                result = RES_OK;
        }
        zCriteria_t() : criteria(){ result = RES_ERROR; }
        zCriteria_t( zval *pz ) : criteria(){ initialize(pz); }
        zCriteria_t( zval **ppz ) : criteria() { initialize(*ppz); }
        result_t getResult(){ return result; };
        
        void dump(){
                zend_printf( "dumping zCriteria...<br>\n" );
                zend_printf( "result=%d<br>\n", (int)result );
                zend_printf( "start=%d, rows=%d<br>\n", getLimitStart(), getLimitRows() );
                const orderby *p = headOrderBy();
                while ( p ){
                        zend_printf( "column=%s, order=%d<br>\n", p->getColumn(), p->getOrder() );
                        p = nextOrderBy();
                }
        }
};


class zAccount_t : public account {
private:
        result_t result;
public:
        void initialize(zval *pz){
                ; // todo
        }
        zAccount_t() : account(){ result = RES_ERROR; }
        zAccount_t( zval *pz ) : account(){ initialize(pz); }
        zAccount_t( zval **ppz ) : account() { initialize(*ppz); }
        result_t getResult(){ return result; };
};

/** zval**縺九ｉ(userid_t *puid,int uidLen)繧堤函謌舌☆繧九◆繧√?繧ｯ繝ｩ繧ｹ縲ら函謌仙､ｱ謨励↑繧曳etResult()!=RES_OK
    uids : array( '1', '3', '4', '6', ... ); 縺薙ｓ縺ｪ蠖｢縺ｮ驟榊?
  */
class zUIDs_t {
private:
        result_t result;
        userid_t *pUID;
        int len;
public:
        zUIDs_t(){
                pUID = 0;
                len = 0;
                result = RES_ERROR;
        }
        
        zUIDs_t( zval *pza ){
                pUID = 0;
                len = 0;
                result = RES_ERROR;
                
                if ( Z_TYPE_P(pza) != IS_ARRAY ){
                        result = RES_ERROR;
                }
                else {
                        len = zend_hash_num_elements(Z_ARRVAL_P(pza));
                        if(len == 0) {
                                pUID = new userid_t[1];
                                result = RES_OK;
                        }
                        else {
                                /* php/ext/standard/string.c 縺ｮ implode縺ｮ縺ゅ◆繧翫ｒ蜿り??↓縲?/span>
                                   zend_hash_*縺ｮ繝峨く繝･繝｡繝ｳ繝医▲縺ｦ縺ゅｋ縺ｮ縺?繧阪≧縺具ｼ?/span>
                                */
                                zval         **tmp;
                                HashPosition   pos;
                                int i = 0;
                                pUID = new userid_t[len];
                                
                                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pza), &pos);
                                while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pza), (void **) &tmp, &pos) == SUCCESS ) {
                                        SEPARATE_ZVAL(tmp); // zend.arguments.write-safety.html 蜿ら?
                                        convert_to_long_ex(tmp);
                                        if ( i < len )
                                                pUID[i++] = Z_LVAL_PP(tmp);
                                        zend_hash_move_forward_ex(Z_ARRVAL_P(pza), &pos);
                                }
                                len = i;
                                result = RES_OK;
                        }
                }
        }
        
        ~zUIDs_t(){
                if ( pUID ) delete[] pUID;
        }
        result_t getResult(){ return result; }
        userid_t *getPUID(){ return pUID; }
        int getLen(){ return len; }
        void dump(){
                zend_printf( "dumping zUIDs...<br>\n" );
                zend_printf( "result=%d<br>\n", (int)result );
                zend_printf( "len=%d<br>\n", len );
                for ( int i = 0; i < len; i++ ){
                        zend_printf( "pUID[%d] = %d<br>\n", i, pUID[i] );
                }
        }
};

/** uids_t 竊 zval
  */
result_t uidsToZval( userid_t *pUID, int len, zval **ppz )
{
        zval *pz;
        
        // create new array
        MAKE_STD_ZVAL(pz);
        array_init(pz);
        
        // add UIDs
        for ( int i = 0; i < len; i++ ){
                add_next_index_long(pz, (long)(pUID[i]) );
        }
        
        // return array
        *ppz = pz;
        return RES_OK;
}
/** uids_t 竊 zval
  */
result_t gidsToZval( groupid_t *pGID, int len, zval **ppz )
{
        zval *pz;
        
        // create new array
        MAKE_STD_ZVAL(pz);
        array_init(pz);
        
        // add GIDs
        for ( int i = 0; i < len; i++ ){
                add_next_index_long(pz, (long)(pGID[i]) );
        }
        
        // return array
        *ppz = pz;
        return RES_OK;
}

/** accounts 竊 zval
  * accounts: 縺薙ｓ縺ｪ諢溘§縺ｮ驟榊? 
    array( 
      array(
        'uid'=>100,
        'activate'=>1,
        'institute'=>'foo',
        'tel'=>'123-456-789',
        ...
      ), 
      ...
    )
  */
result_t accountsToZval( const account_t *pAccounts, int accountLen, zval *z )
{
        return RES_ERROR;
}

result_t accountToZval( const account_t *pAccount, zval *z )
{
        return RES_ERROR;
}

/** groups 竊 zval
  */
result_t groupsToZval( const group_t *pGroups, int groupLen, zval *z )
{

        return RES_ERROR;
}

/** session 竊 zval
  */
result_t sessionToZval( const session_t *pSession, zval *z )
{
        string sessionID(unsignedIntToString(pSession->getSessionID()));
        add_assoc_string(z, "session_id", (char *)sessionID.c_str(), 1);
        
        string date(unsignedIntToString((unsigned int)pSession->getDate()));
        add_assoc_string(z, "date", (char *)date.c_str(), 1);
        
        string userID(unsignedIntToString((unsigned int)pSession->getUserID()));
        add_assoc_string(z, "user_id", (char *)userID.c_str(), 1);
        
        return RES_OK;
}

ZEND_FUNCTION(vp_test_criteria)
{
        zval *z;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", 
          &z) == FAILURE) {
                return;
        }
        zend_printf("zend_printf...<br>\n");
        zCriteria_t zcri(z);
        zcri.dump();
        RETURN_FALSE
}

ZEND_FUNCTION(vp_test_uids)
{
        zval *z;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", 
          &z) == FAILURE) {
                return;
        }
        zend_printf("zend_printf...<br>\n");
        zUIDs_t zuids(z);
        zuids.dump();
        RETURN_FALSE
}


/** DB縺ｫ謗･邯壹☆繧九?よ里縺ｫ謗･邯壻ｸｭ縺ｮ謗･邯壹?髢峨§繧峨ｌ繧九??lt;br>
    int initialize_db( string host[, string user[, string password[, string dbname[, string prefix]]]] );
    @param host      謗･邯壼?縲ら怐逡･譎ゅ?NULL
    @param user      DB謗･邯壽凾縺ｮ繝ｦ繝ｼ繧ｶ蜷阪?ら怐逡･譎ゅ?NULL
    @param password  DB謗･邯壽凾縺ｮ繝代せ繝ｯ繝ｼ繝峨?ら怐逡･譎ゅ?NULL
    @param dbname    DB謗･邯壽凾縺ｮDB蜷阪?ら怐逡･譎ゅ?""
    @param prefix    XOOPS DB 縺ｮprefix縲?/span>
    @return 0 success <br>
  */
ZEND_FUNCTION(vp_initialize_db)
{
        zval **parameters[5];
        char *host;
        char *user;
        char *password;
        char *dbname;
        char *prefix;

        /* get the number of arguments */
        int argNum = ZEND_NUM_ARGS();
        if (argNum > 5)
                WRONG_PARAM_COUNT;

        /* argument count is correct, now retrieve arguments */
        if(zend_get_parameters_array_ex(argNum, parameters) != SUCCESS)
                WRONG_PARAM_COUNT;

        if (argNum < 1) host = NULL;
        else            host = getZvalString( parameters[0] );
        
        if (argNum < 2) user = NULL;
        else            user = getZvalString( parameters[1] );
        
        if (argNum < 3) password = NULL;
        else            password = getZvalString( parameters[2] );
        
        if (argNum < 4) dbname = "";
        else            dbname = getZvalString( parameters[3] );
        
        if (argNum < 5) prefix = "";
        else            prefix = getZvalString( parameters[4] );
        
        result_t result = initializeDB( host, user, password, dbname, prefix );
        
        RETURN_LONG(result);
}

/** 繝ｭ繧ｰ繧､繝ｳ縺吶ｋ縲?lt;br>
    int vp_login_user(string uname, string password)
    @param uname      繝ｦ繝ｼ繧ｶ蜷?xoops_users.uname)
    @param password   繝代せ繝ｯ繝ｼ繝?md5(password)=xoops_users.pass)
    @return 0 success 
  */
ZEND_FUNCTION(vp_login_user)
{
        char *uname;
        int unameLen;
        char *passwd;
        int passwdLen;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", 
          &uname, &unameLen, &passwd, &passwdLen) == FAILURE) {
                return;
        }
        
        string strUname( uname, unameLen );
        string strPasswd( passwd, passwdLen );
        sessionid_t vpSessionID;
        result_t result = loginUser( strUname.c_str(), strPasswd.c_str(), &vpSessionID );
        if ( result == RES_OK ){
            RETURN_LONG((long)vpSessionID);
        }
        else {
                //zend_printf( "vpal_debug: vp_login_user(%s, %s): cannot login. result=%d<br>\n", strUname.c_str(), strPasswd.c_str(), (int)result );
                RETURN_FALSE
        }
}

/** 繝ｭ繧ｰ繧｢繧ｦ繝医☆繧九??lt;br>
    void vp_logout_user(int vp_session_id)
    @param vp_session_id  vp縺ｮsessionid
    @return 縺ｪ縺?/span>
  */
ZEND_FUNCTION(vp_logout_user)
{
        long vpSessionID;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &vpSessionID) == FAILURE) {
                return;
        }
        
        logoutUser( (sessionid_t)vpSessionID );
        
    RETURN_NULL();
}

/** vp 縺ｮ session id 菴懈?<br>
    int vp_create_session( string xoops_sess_id, int uid, string remote_host )
    @param xoops_sess_id  xoops縺ｮsession id
    @param uid  xoops 縺ｮ uid (xoops_users.uid)
    @return FALSE莉･螟? vp 縺ｮ session id
    @return FALSE: 螟ｱ謨?/span>
  */
ZEND_FUNCTION(vp_create_session)
{
        char *xoopsSessionID;
        int xoopsSessionIDLen;
        long sid, uid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl",
          &xoopsSessionID, &xoopsSessionIDLen, &uid) == FAILURE) {
                return;
        }
        
        sessionid_t vpSessionID = 0;
        result_t result = createSession( xoopsSessionID, (userid_t)uid, &vpSessionID );
        if ( result == RES_OK ){
                RETURN_LONG((long)vpSessionID);
        }
        else {
                RETURN_FALSE;
        }
}

/** vp 縺ｮ session 縺ｮ隧ｳ邏ｰ諠??ｱ繧貞ｾ励ｋ<br>
    int vp_get_session( int vp_session_id, array session_info )
    @param vp_session_id   vp 縺ｮ session id
    @param session_info  邨先棡繧貞女縺大叙繧矩?蛻?/span>
    @return 0 success
  */
ZEND_FUNCTION(vp_get_session)
{
        long vpSessionID;
        zval *sessionInfo;
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
          &vpSessionID, &sessionInfo) == FAILURE) {
                return;
        }
        const session_t *session = 0;
        result_t result = getSession( (sessionid_t)vpSessionID, &session );
        if ( result == RES_OK ){
                sessionToZval( session, sessionInfo );
                freeResult( session );
        }
        
        RETURN_LONG((long)result);
}

ZEND_FUNCTION(vp_is_activated)
{
        long sid, uid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
          &sid, &uid) == FAILURE) {
                return;
        }
        
        bool result = isActivated( (sessionid_t)sid, (userid_t)uid );
        
    RETURN_BOOL(result);
}

ZEND_FUNCTION(vp_activate)
{
        long sid, uid;
        bool activated;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llb",
          &sid, &uid, &activated) == FAILURE) {
                return;
        }
        
        result_t result = activate( (sessionid_t)sid, (userid_t)uid, activated );
        
    RETURN_LONG(result);
}

ZEND_FUNCTION(vp_get_account_count)
{
        long sid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
          &sid) == FAILURE) {
                return;
        }
        
        long count = getAccountCount( (sessionid_t)sid );
        
    RETURN_LONG(count);
}

ZEND_FUNCTION(vp_delete_account)
{
        long sid, uid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll",
          &sid, &uid) == FAILURE) {
                return;
        }
        
        result_t result = deleteAccount( (sessionid_t)sid, (userid_t)uid );
        
    RETURN_LONG(result);
}

// int vp_get_account( int sid, int uid, array account )
ZEND_FUNCTION(vp_get_account)
{
        long sid, uid;
        zval *zaccount;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
          &sid, &uid, &zaccount) == FAILURE) {
                return;
        }
        
        const account_t *paccount;
        result_t result = getAccount( (sessionid_t)sid, (userid_t)uid, &paccount );
        if ( RES_OK == result ){
                accountToZval( paccount, zaccount );
                freeResult( paccount );
        }
        
    RETURN_LONG(result);
}

// int vp_get_accoutns( int sid, array uids, array criteria, array accounts );
ZEND_FUNCTION(vp_get_accounts)
{
        result_t result;
        long sid;
        zval *zuids;
        zval *zcriteria;
        zval *zaccount;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
          &sid, &zuids, &zcriteria, &zaccount) == FAILURE) {
                return;
        }
        
        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                zUIDs_t zUIDs(zuids);
                result = zUIDs.getResult();
                if ( RES_OK == result ){
                        const account_t *paccounts;
                        int accountLen;
                        result = getAccounts( (sessionid_t)sid, 
                                zUIDs.getPUID(), zUIDs.getLen(),
                                &zcri, &paccounts, &accountLen );
                        if ( RES_OK == result ){
                                accountsToZval( paccounts, accountLen, zaccount );
                                freeResult( paccounts );
                        }
                }
        }
        
    RETURN_LONG(result);
}

// int vp_insert_account( int sid, array account );
ZEND_FUNCTION(vp_insert_account)
{
        result_t result;
        long sid;
        zval *zaccount;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
          &sid, &zaccount) == FAILURE) {
                return;
        }
        
        zAccount_t zacc(zaccount);
        result = zacc.getResult();
        if ( RES_OK == result ){
                result = insertAccount( (sessionid_t)sid, &zacc );
        }
        
    RETURN_LONG(result);
}

// int vp_update_account( int sid, array account );
ZEND_FUNCTION(vp_update_account)
{
        result_t result;
        long sid;
        zval *zaccount;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la",
          &sid, &zaccount) == FAILURE) {
                return;
        }
        
        zAccount_t zacc(zaccount);
        result = zacc.getResult();
        if ( RES_OK == result ){
                result = updateAccount( (sessionid_t)sid, &zacc );
        }
        
    RETURN_LONG(result);
}

// int vp_dump_uids( int sid, array criteria, array uids );
ZEND_FUNCTION(vp_dump_uids)
{
        result_t result;
        long sid;
        zval *zcriteria;
        zval *zuids;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
          &sid, &zcriteria, &zuids) == FAILURE) {
                return;
        }
        
        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                userid_t *puid;
                int uidLen;
                result = dumpUids( (sessionid_t)sid, &zcri, &puid, &uidLen );
                if ( RES_OK == result ){
                        uidsToZval( puid, uidLen, &zuids );
                        freeResult( puid );
                }
        }
        
    RETURN_LONG(result);
}

// int vp_get_group_count( int sid );
ZEND_FUNCTION(vp_get_group_count)
{
        result_t result;
        long sid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
          &sid) == FAILURE) {
                return;
        }
        
        int count = getGroupCount( (sessionid_t)sid );
        
    RETURN_LONG(count);
}

// int vp_get_group_by_uid( int sid, int uid, array criteria, array gids );
ZEND_FUNCTION(vp_get_groups_by_uid)
{
        result_t result;
        long sid, uid;
        zval *zcriteria;
        zval *zgids;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa",
          &sid, &uid, &zcriteria, &zgids) == FAILURE) {
                return;
        }
        
        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                groupid_t *pgids;
                int gidLen;
                result = getGroupsByUid( (sessionid_t)sid, (userid_t)uid, &zcri, &pgids, &gidLen );
                if ( RES_OK == result ){
                        gidsToZval( pgids, gidLen, &zgids );
                        freeResult( pgids );
                }
        }
        
    RETURN_LONG(result);
}


// int vp_is_group_admin( int sid, int gid, int uid );
ZEND_FUNCTION(vp_is_group_admin)
{
        result_t result;
        long sid, gid, uid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll",
          &sid, &gid, &uid) == FAILURE) {
                return;
        }
        
        bool b  = isGroupAdmin( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid );
        
    RETURN_BOOL(b);
}

// int vp_dump_gids( int sid, array criteria, array gids );
ZEND_FUNCTION(vp_dump_gids)
{
        result_t result;
        long sid;
        zval *zcriteria;
        zval *zgids;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laa",
          &sid, &zcriteria, &zgids) == FAILURE) {
                return;
        }
        
        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
                groupid_t *pgid;
                int gidLen;
                result = dumpGids( (sessionid_t)sid, &zcri, &pgid, &gidLen );
                if ( RES_OK == result ){
                        gidsToZval( pgid, gidLen, &zgids );
                        freeResult( pgid );
                }
        }
        
    RETURN_LONG(result);
}