xoonips/AL/xnpal.cc

/*
        $Revision: 1.19 $
        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

PHP_MSHUTDOWN_FUNCTION(vpalmod)
{
        uninitializeDB();
        return SUCCESS;
}

/* 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_is_valid_session_id );
ZEND_FUNCTION(vp_get_last_error_string );

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_is_valid_session_id ,NULL)
    ZEND_FE(vp_get_last_error_string ,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, 
        PHP_MSHUTDOWN(vpalmod),
    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 <br>
    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;

        // 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, "name", keyLen ) == 0 && keyLen == 5 ){
                                        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;
        }

public:
        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();
                }
        }
};


/** 騾｣諠ｳ驟榊?縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺励※long蛟､繧貞ｾ励ｋ縲?/span>
  @param   ht   騾｣諠ｳ驟榊?
  @param   key  繧ｭ繝ｼ
  @param   val  long蛟､繧貞女縺大叙繧九?繧､繝ｳ繧ｿ
  @return  謌仙粥縺ｪ繧液rue
 */
static bool hashGetLong( HashTable *ht, const char *key, long *val ){
    zval         **tmp;
    if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
        convert_to_long_ex( tmp );
        *val = Z_LVAL_PP(tmp);
        return true;
    }
    return false;
}

/** 騾｣諠ｳ驟榊?縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺励※譁?ｭ怜?繧貞ｾ励ｋ縲?/span>
  @param   ht   騾｣諠ｳ驟榊?
  @param   key  繧ｭ繝ｼ
  @param   val  譁?ｭ怜?繧貞女縺大叙繧九?繧､繝ｳ繧ｿ
  @return  謌仙粥縺ｪ繧液rue
 */
static bool hashGetString( HashTable *ht, const char *key, char **val ){
    zval         **tmp;
    if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
        convert_to_string_ex( tmp );
        *val = Z_STRVAL_PP(tmp);
        return true;
    }
    return false;
}

/** 騾｣諠ｳ驟榊?縺ｫ繧｢繧ｯ繧ｻ繧ｹ縺励※double蛟､繧貞ｾ励ｋ縲?/span>
  @param   ht   騾｣諠ｳ驟榊?
  @param   key  繧ｭ繝ｼ
  @param   val  double蛟､繧貞女縺大叙繧九?繧､繝ｳ繧ｿ
  @return  謌仙粥縺ｪ繧液rue
 */
static bool hashGetDouble( HashTable *ht, const char *key, double *val ){
    zval         **tmp;
    if( zend_hash_find( ht, (char *)key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
        convert_to_double_ex( tmp );
        *val = Z_DVAL_PP(tmp);
        return true;
    }
    return false;
}

/** zval*縺九ｉaccount繧堤函謌舌☆繧九◆繧√?繧ｯ繝ｩ繧ｹ縲 <br>
    逕滓?螟ｱ謨励↑繧曳etResult()!=RES_OK <br>
  */
class zAccount_t : public account {
private:
        result_t result;
        void initialize(zval *pz){
                HashTable *ht = Z_ARRVAL_P(pz);
                long l;
                char *p;
                double d;
                if ( hashGetLong  ( ht, "uid"               , &l ) ) setUID              ( l );
                if ( hashGetString( ht, "uname"             , &p ) ) setUname            ( p );
                if ( hashGetString( ht, "name"              , &p ) ) setName             ( p );
                if ( hashGetString( ht, "email"             , &p ) ) setEmail            ( p );
                if ( hashGetString( ht, "url"               , &p ) ) setURL              ( p );
                if ( hashGetString( ht, "user_avatar"       , &p ) ) setUserAvatar       ( p );
                if ( hashGetString( ht, "user_icq"          , &p ) ) setUserIcq          ( p );
                if ( hashGetString( ht, "user_from"         , &p ) ) setUserFrom         ( p );
                if ( hashGetString( ht, "user_sig"          , &p ) ) setUserSig          ( p );
                if ( hashGetString( ht, "actkey"            , &p ) ) setActkey           ( p );
                if ( hashGetString( ht, "user_aim"          , &p ) ) setUserAim          ( p );
                if ( hashGetString( ht, "user_yim"          , &p ) ) setUserYim          ( p );
                if ( hashGetString( ht, "user_msnm"         , &p ) ) setUserMsnm         ( p );
                if ( hashGetString( ht, "pass"              , &p ) ) setPass             ( p );
                if ( hashGetString( ht, "theme"             , &p ) ) setTheme            ( p );
                if ( hashGetString( ht, "umode"             , &p ) ) setUmode            ( p );
                if ( hashGetString( ht, "user_occ"          , &p ) ) setUserOcc          ( p );
                if ( hashGetString( ht, "bio"               , &p ) ) setBio              ( p );
                if ( hashGetString( ht, "user_intrest"      , &p ) ) setUserIntrest      ( p );
                if ( hashGetDouble( ht, "timezone_offset"   , &d ) ) setTimezoneOffset   ( d );
                if ( hashGetLong  ( ht, "attachsig"         , &l ) ) setAttachsig        ( l );
                if ( hashGetLong  ( ht, "last_login"        , &l ) ) setLastLogin        ( l );
                if ( hashGetLong  ( ht, "level"             , &l ) ) setLevel            ( l );
                if ( hashGetLong  ( ht, "notify_method"     , &l ) ) setNotifyMethod     ( l );
                if ( hashGetLong  ( ht, "notify_mode"       , &l ) ) setNotifyMode       ( l );
                if ( hashGetLong  ( ht, "posts"             , &l ) ) setPosts            ( l );
                if ( hashGetLong  ( ht, "rank"              , &l ) ) setRank             ( l );
                if ( hashGetLong  ( ht, "uorder"            , &l ) ) setUorder           ( l );
                if ( hashGetLong  ( ht, "user_mailok"       , &l ) ) setUserMailok       ( l );
                if ( hashGetLong  ( ht, "user_regdate"      , &l ) ) setUserRegdate      ( l );
                if ( hashGetLong  ( ht, "user_viewemail"    , &l ) ) setUserViewemail    ( l );
                if ( hashGetLong  ( ht, "activate"          , &l ) ) setActivate         ( l );
                if ( hashGetString( ht, "address"           , &p ) ) setAddress          ( p );
                if ( hashGetString( ht, "division"          , &p ) ) setDivision         ( p );
                if ( hashGetString( ht, "tel"               , &p ) ) setTel              ( p );
                if ( hashGetString( ht, "company_name"      , &p ) ) setCompanyName      ( p );
                if ( hashGetString( ht, "country"           , &p ) ) setCountry          ( p );
                if ( hashGetString( ht, "zipcode"           , &p ) ) setZipcode          ( p );
                if ( hashGetString( ht, "fax"               , &p ) ) setFax              ( p );
                if ( hashGetString( ht, "base_url"          , &p ) ) setBaseURL          ( p );
                if ( hashGetLong  ( ht, "notice_mail"       , &l ) ) setNoticeMail       ( l );
                if ( hashGetLong  ( ht, "notice_mail_since" , &l ) ) setNoticeMailSince  ( l );

                result = RES_OK;
        }
public:
        zAccount_t() : account(){ result = RES_ERROR; }
    
    /** 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
      @param pz  array( 'uid'=>1, 'uname'=>'root', ... ); 縺薙ｓ縺ｪ蠖｢縺ｮ騾｣諠ｳ驟榊? */
        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)繧堤函謌舌☆繧九◆繧√?繧ｯ繝ｩ繧ｹ縲 <br>
    逕滓?螟ｱ謨励↑繧曳etResult()!=RES_OK <br>
  */
class zUIDs_t {
private:
        result_t result;
        userid_t *pUID;
        int len;
public:
        zUIDs_t(){
                pUID = 0;
                len = 0;
                result = RES_ERROR;
        }
        
    /** 繧ｳ繝ｳ繧ｹ繝医Λ繧ｯ繧ｿ
      @param pza  array( '1', '3', '4', '6', ... ); 縺薙ｓ縺ｪ蠖｢縺ｮ驟榊? */
        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縺ｮ驟榊?繧単HP縺ｮ驟榊?縺ｫ螟画鋤縺吶ｋ
 * 
 * @param pUID 螟画鋤蜈??userid_t縺ｮ驟榊?
 * @param len pUID縺ｮ驟榊?縺ｮ髟ｷ縺?/span>
 * @param pz 螟画鋤邨先棡繧呈嶌縺崎ｾｼ繧?驟榊?(蛻晄悄蛹匁ｸ医∩縺ｧ縺ゅｋ縺薙→)
 * @return RES_OK
 * 
 */
result_t uidsToZval( userid_t *pUID, int len, zval **ppz )
{
    zend_hash_clean( Z_ARRVAL_PP(ppz) );
        
        // add UIDs
        for ( int i = 0; i < len; i++ ){
                add_next_index_long(*ppz, (long)(pUID[i]) );
        }
        
        return RES_OK;
}
/**
 *
 * groupid_t縺ｮ驟榊?繧単HP縺ｮ驟榊?縺ｫ螟画鋤縺吶ｋ
 * @param pGID 螟画鋤蜈??groupid_t縺ｮ驟榊?
 * @param len  pGID縺ｮ驟榊?縺ｮ髟ｷ縺?/span>
 * @param ppz  螟画鋤邨先棡繧呈嶌縺崎ｾｼ繧?驟榊?(蛻晄悄蛹匁ｸ医∩縺ｧ縺ゅｋ縺薙→)
 * @return RES_OK
 *
 */
result_t gidsToZval( groupid_t *pGID, int len, zval **ppz )
{
    zend_hash_clean( Z_ARRVAL_PP(ppz) );
        
        // add GIDs
        for ( int i = 0; i < len; i++ ){
                add_next_index_long(*ppz, (long)(pGID[i]) );
        }
        
        return RES_OK;
}


/**
 *
 * account_t縺ｮ蜀?ｮｹ繧単HP縺ｮ驟榊?縺ｫ螟画鋤縺吶ｋ
 * @param pAccount 螟画鋤蜈??account_t*
 * @param z        螟画鋤邨先棡繧呈嶌縺崎ｾｼ繧?驟榊?(蛻晄悄蛹匁ｸ医∩縺ｧ縺ゅｋ縺薙→)
 * @return RES_OK
 *
 */
result_t accountToZval( const account_t *pAccount, zval *z )
{
    zend_hash_clean( z -> value.ht );
    
    add_assoc_long( z, "uid", pAccount -> getUID( ) );
    add_assoc_string( z, "uname", ( char* )pAccount -> getUname( ), 1 );
    add_assoc_string( z, "name", ( char* )pAccount -> getName( ), 1 );
    add_assoc_string( z, "email", ( char* )pAccount -> getEmail( ), 1 );
    add_assoc_string( z, "url", ( char* )pAccount -> getURL( ), 1 );
    add_assoc_string( z, "user_avatar", ( char* )pAccount -> getUserAvatar( ), 1 );
    add_assoc_string( z, "user_icq", ( char* )pAccount -> getUserIcq( ), 1 );
    add_assoc_string( z, "user_from", ( char* )pAccount -> getUserFrom( ), 1 );
    add_assoc_string( z, "user_sig", ( char* )pAccount -> getUserSig( ), 1 );
    add_assoc_string( z, "actkey", ( char* )pAccount -> getActkey( ), 1 );
    add_assoc_string( z, "user_aim", ( char* )pAccount -> getUserAim( ), 1 );
    add_assoc_string( z, "user_yim", ( char* )pAccount -> getUserYim( ), 1 );
    add_assoc_string( z, "user_msnm", ( char* )pAccount -> getUserMsnm( ), 1 );
    add_assoc_string( z, "pass", ( char* )pAccount -> getPass( ), 1 );
    add_assoc_string( z, "theme", ( char* )pAccount -> getTheme( ), 1 );
    add_assoc_string( z, "umode", ( char* )pAccount -> getUmode( ), 1 );
    add_assoc_string( z, "user_occ", ( char* )pAccount -> getUserOcc( ), 1 );
    add_assoc_string( z, "bio", ( char* )pAccount -> getBio( ), 1 );
    add_assoc_string( z, "user_intrest", ( char* )pAccount -> getUserIntrest( ), 1 );
    add_assoc_double( z, "timezone_offset", pAccount -> getTimezoneOffset( ) );
    add_assoc_long( z, "attachsig", pAccount -> getAttachsig( ) );
    add_assoc_long( z, "last_login", pAccount -> getLastLogin( ) );
    add_assoc_long( z, "level", pAccount -> getLevel( ) );
    add_assoc_long( z, "notify_method", pAccount -> getNotifyMethod( ) );
    add_assoc_long( z, "notify_mode", pAccount -> getNotifyMode( ) );
    add_assoc_long( z, "posts", pAccount -> getPosts( ) );
    add_assoc_long( z, "rank", pAccount -> getRank( ) );
    add_assoc_long( z, "uorder", pAccount -> getUorder( ) );
    add_assoc_long( z, "user_mailok", pAccount -> getUserMailok( ) );
    add_assoc_long( z, "user_regdate", pAccount -> getUserRegdate( ) );
    add_assoc_long( z, "user_viewemail", pAccount -> getUserViewemail( ) );
    
    add_assoc_long( z, "activate", pAccount -> getActivate( ) );
    add_assoc_string( z, "address", ( char* )pAccount -> getAddress( ), 1 );
    add_assoc_string( z, "division", ( char* )pAccount -> getDivision( ), 1 );
    add_assoc_string( z, "tel", ( char* )pAccount -> getTel( ), 1 );
    add_assoc_string( z, "company_name", ( char* )pAccount -> getCompanyName( ), 1 );
    add_assoc_string( z, "country", ( char* )pAccount -> getCountry( ), 1 );
    add_assoc_string( z, "zipcode", ( char* )pAccount -> getZipcode( ), 1 );
    add_assoc_string( z, "fax", ( char* )pAccount -> getFax( ), 1 );
    add_assoc_string( z, "base_url", ( char* )pAccount -> getBaseURL( ), 1 );
    add_assoc_long( z, "notice_mail", pAccount -> getNoticeMail( ) );
    add_assoc_long( z, "notice_mail_since", pAccount -> getNoticeMailSince( ) );
        return RES_OK;
}
/**
 *
 * 隍?焚縺ｮaccount_t縺ｮ蜀?ｮｹ繧単HP縺ｮ驟榊?縺ｮ驟榊?縺ｫ螟画鋤縺吶ｋ
 * @param pAccounts 螟画鋤蜈??account_t*
 * @param accountsLen pAccounts縺ｮ驟榊?縺ｮ髟ｷ縺?/span>
 * @param z        螟画鋤邨先棡繧呈嶌縺崎ｾｼ繧?驟榊?(蛻晄悄蛹匁ｸ医∩縺ｧ縺ゅｋ縺薙→)
 * @return RES_OK
 *
  z: 縺薙ｓ縺ｪ諢溘§縺ｮ驟榊?縺ｫ縺ｪ繧九?や? <br>
    array( 
      array(
        'uid'=>100,
        'activate'=>1,
        'division'=>'foo',
        'tel'=>'123-456-789',
        ...
      ), 
      ...
    )
 */
result_t accountsToZval( const account_t *pAccounts, int accountsLen, zval *z )
{
    zend_hash_clean( z -> value.ht );
    for( int i = 0; i < accountsLen; i++ ){
        zval *new_array;
        MAKE_STD_ZVAL(new_array);
        if(array_init(new_array) != SUCCESS){
            return RES_ERROR;
        }
        add_index_zval( z, i, new_array );
        accountToZval( &pAccounts[ i ], new_array );
    }
        return RES_OK;
}

/**
 *
 * 隍?焚縺ｮgroup_t縺ｮ蜀?ｮｹ繧単HP縺ｮ驟榊?縺ｮ驟榊?縺ｫ螟画鋤縺吶ｋ
 * @param pGroups 螟画鋤蜈??group_t*
 * @param groupsLen pGroups縺ｮ驟榊?縺ｮ髟ｷ縺?/span>
 * @param z        螟画鋤邨先棡繧呈嶌縺崎ｾｼ繧?驟榊?(蛻晄悄蛹匁ｸ医∩縺ｧ縺ゅｋ縺薙→)
 * @return RES_OK
 *
  z: 縺薙ｓ縺ｪ諢溘§縺ｮ驟榊?縺ｫ縺ｪ繧九?や? <br>
    array( 
      array(
        'gid'=>1,
        'gname'=>'foo group',
        'gdesc'=>'group of foo'
      ), 
      ...
    )
 */
result_t groupsToZval( const group_t *pGroups, int groupsLen, zval *z )
{
    zend_hash_clean( z -> value.ht );
    for( int i = 0; i < groupsLen; i++ ){
        zval *new_array;
        MAKE_STD_ZVAL(new_array);
        if(array_init(new_array) != SUCCESS){
            return RES_ERROR;
        }
        add_index_zval( z, i, new_array );
        add_assoc_long( new_array, "gid",  pGroups[ i ].getGID( ) );
        add_assoc_string( new_array, "gname", ( char* )pGroups[ i ].getGname( ), 1 );
        add_assoc_string( new_array, "gdesc", ( char* )pGroups[ i ].getDesc( ), 1 );
    }
        return RES_OK;
}

/**
 * 
 * group_t縺ｮ蜀?ｮｹ繧単HP縺ｮ騾｣諠ｳ驟榊?縺ｫ螟画鋤縺吶ｋ
 * 
 * @param pGroup 螟画鋤蜈??繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ
 * @param z 螟画鋤邨先棡繧呈嶌縺崎ｾｼ繧?騾｣諠ｳ驟榊?(蛻晄悄蛹匁ｸ医∩縺ｧ縺ゅｋ縺薙→)
 * @return RES_OK
 * 
 */
result_t groupToZval( const group_t *pGroup, zval *z )
{
    zend_hash_clean( z -> value.ht );
    add_assoc_long( z, "gid",  pGroup -> getGID( ) );
    add_assoc_string( z, "gname", ( char* )pGroup -> getGname( ), 1 );
    add_assoc_string( z, "gdesc", ( char* )pGroup -> getDesc( ), 1 );
        return RES_OK;
}

/**
 * 
 * PHP縺ｮ騾｣諠ｳ驟榊?縺ｮ蜀?ｮｹ繧暖roup_t縺ｫ螟画鋤縺吶ｋ
 * 
 * @param z 螟画鋤蜈??騾｣諠ｳ驟榊?
 * @param pGroup 螟画鋤邨先棡繧呈嶌縺崎ｾｼ繧?繧ｰ繝ｫ繝ｼ繝?/span>
 * @return RES_OK
 * 
 */
result_t zvalToGroup( zval *z, group_t *pGroup )
{
    zval         **tmp;
    HashPosition   pos;
    int i = 0;
    char* key = 0;
    
    key = "gid";
    if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
        convert_to_long_ex( tmp ) ;
        pGroup -> setGID( (*tmp) -> value.lval );
    }    
    key = "gname";
    if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
        convert_to_string_ex( tmp ) ;
        pGroup -> setGname( (*tmp) -> value.str.val );
    }    
    key = "gdesc";
    if( zend_hash_find( z -> value.ht, key, strlen( key ) + 1, ( void** )&tmp ) == SUCCESS ){
        convert_to_string_ex( tmp ) ;
        pGroup -> setDesc( (*tmp) -> value.str.val );
    }
        return RES_OK;
}

/**
 * 
 * session_t縺ｮ蜀?ｮｹ繧単HP縺ｮ騾｣諠ｳ驟榊?縺ｫ螟画鋤縺吶ｋ
 * 
 * @param pSession 螟画鋤蜈??session_t
 * @param z 螟画鋤邨先棡繧呈嶌縺崎ｾｼ繧?騾｣諠ｳ驟榊?(蛻晄悄蛹匁ｸ医∩縺ｧ縺ゅｋ縺薙→)
 * @return RES_OK
 * 
 */
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->getUID()));
        add_assoc_string(z, "user_id", (char *)userID.c_str(), 1);
        
        return RES_OK;
}


/** 謖?ｮ壹＠縺溘げ繝ｫ繝ｼ繝励?諠??ｱ繧貞ｾ励ｋ<br>
    int vp_get_group( int sid, int gid, array group );
    @param sid    VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param gid    VP 縺ｮ group_id
    @param group  邨先棡繧貞女縺大叙繧矩?蛻?/span>
    @return 0 success <br>
  */
ZEND_FUNCTION(vp_get_group)
{
        long sid, gid;
        zval *zgroup;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
                              &sid, &gid, &zgroup) == FAILURE) {
                return;
        }
        
        const group_t *pgroup;
        result_t result = getGroup( (sessionid_t)sid, (groupid_t)gid, &pgroup );
        if ( RES_OK == result ){
                groupToZval( pgroup, zgroup );
                freeGroup( pgroup );
        }
        
    RETURN_LONG(result);
}


/** 謖?ｮ壹＠縺溘げ繝ｫ繝ｼ繝?隍?焚)縺ｮ諠??ｱ繧貞ｾ励ｋ<br>
    vp_get_groups( int sid, array gids, array criteria, array groups );
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param gids     VP 縺ｮ group_id 縺ｮ驟榊?
    @param criteria 譚｡莉ｶ
    @param groups   邨先棡繧貞女縺大叙繧矩?蛻励?驟榊?
    @return 0 success <br>
  */
ZEND_FUNCTION(vp_get_groups)
{
        result_t result;
        long sid, uid;
        zval *zcriteria;
        zval *zgids;
        zval *zgroups;
    zval **ppzTmp = 0;
    HashPosition pos;
    int res2;
    int gidsLen;
    const group_t* groups;
    int groupsLen;
    
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laaa",
                              &sid, &zgids, &zcriteria, &zgroups) == FAILURE) {
                return;
        }
        
    //gids縺ｫ繧ｰ繝ｫ繝ｼ繝悠D繧偵さ繝斐?縺吶ｋ
    gidsLen = zend_hash_num_elements(Z_ARRVAL_P(zgids));
    groupid_t *gids = new groupid_t[ gidsLen ];
    zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(zgids), &pos);
    for( int i = 0; i < gidsLen; i++ ){
        if( (res2=zend_hash_get_current_data_ex(Z_ARRVAL_P(zgids), (void **)&ppzTmp, &pos)) == SUCCESS ){
            SEPARATE_ZVAL(ppzTmp);
            convert_to_long_ex(ppzTmp);
            gids[ i ] = Z_LVAL_PP(ppzTmp);
        }
        zend_hash_move_forward_ex(Z_ARRVAL_P(zgids), &pos);
    }
    
        zCriteria_t zcri(zcriteria);
        result = zcri.getResult();
        if ( RES_OK == result ){
        result = getGroups( (sessionid_t)sid, gids, gidsLen, &zcri, &groups, &groupsLen );
        if ( RES_OK == result ){
            groupsToZval( groups, groupsLen, zgroups );
            delete[] gids;
            freeGroup( groups );
        }
    }
    RETURN_LONG(result);
}


/** 謖?ｮ壹＠縺溘Θ繝ｼ繧ｶ縺後Δ繝?Ξ繝ｼ繧ｿ縺九←縺?°繧定ｪｿ縺ｹ繧?lt;br>
    int vp_is_moderator(int sid, int uid)
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param uid      xoops 縺ｮ uid (xoops_users.uid)
    @return true  繝｢繝?Ξ繝ｼ繧ｿ縺ｧ縺ゅｋ <br>
  */
ZEND_FUNCTION(vp_is_moderator)
{
        long vpSessionID;
        userid_t uid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", 
                              &vpSessionID, &uid) == FAILURE) {
                return;
        }
        
        bool result = isModerator( (sessionid_t)vpSessionID, uid );
    RETURN_BOOL(result)
}

/** 繝ｦ繝ｼ繧ｶ蜷阪°繧疫id繧定ｪｿ縺ｹ繧?lt;br>
    int vp_get_uid(string uname,int &uid)
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param uname    xoops 縺ｮ uname (xoops_users.uname)
    @param uid      xoops 縺ｮ uid (xoops_users.uid) 繧貞女縺大叙繧句､画焚
    @return 0 success 
  */
ZEND_FUNCTION(vp_get_uid)
{
        char *uname;
        int unameLen;
        zval *zuid;
        userid_t uid;
    
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", 
          &uname, &unameLen, &zuid) == FAILURE) {
                return;
        }
        
        if (!PZVAL_IS_REF(zuid)) {
                zend_error(E_WARNING, "2nd parameter wasn't passed by reference");
                RETURN_LONG(RES_PHP_NONREF);
        }
        
        string strUname( uname, unameLen );
        result_t result = getUid( strUname.c_str(), &uid );
        ZVAL_LONG(zuid, (long)uid);
        RETURN_LONG((long)result);
}

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, int &session_id)
    @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;
        zval *zVPSessionID;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssz", 
          &uname, &unameLen, &passwd, &passwdLen, &zVPSessionID) == FAILURE) {
                return;
        }
        
        if (!PZVAL_IS_REF(zVPSessionID)) {
                zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
                RETURN_LONG(RES_PHP_NONREF);
        }
        
        sessionid_t vpSessionID;
        result_t result = loginUser( uname, passwd, &vpSessionID );
        if ( result == RES_OK )
                ZVAL_LONG(zVPSessionID, (long)vpSessionID);
        RETURN_LONG((long)result);
}

/** 繝ｭ繧ｰ繧｢繧ｦ繝医☆繧九??lt;br>
    void vp_logout_user(int vp_session_id)
    @param vp_session_id  VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @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縺ｮ繧ｻ繝?す繝ｧ繝ｳID 菴懈?<br>
    int vp_create_session( string xoops_sess_id, int uid, int &session )
    @param xoops_sess_id  xoops縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param uid  xoops 縺ｮ uid (xoops_users.uid)
    @param session  菴懈?縺励◆VP縺ｮsession繧貞女縺大叙繧句､画焚
    @return 0 謌仙粥
  */
ZEND_FUNCTION(vp_create_session)
{
        char *xoopsSessionID;
        int xoopsSessionIDLen;
        long uid;
        zval *zVPSessionID;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "slz",
          &xoopsSessionID, &xoopsSessionIDLen, &uid, &zVPSessionID) == FAILURE) {
                return;
        }
        
        if (!PZVAL_IS_REF(zVPSessionID)) {
                zend_error(E_WARNING, "3rd parameter wasn't passed by reference");
                RETURN_LONG(RES_PHP_NONREF);
        }
        
        sessionid_t vpSessionID = 0;
        result_t result = createSession( xoopsSessionID, (userid_t)uid, &vpSessionID );
        if ( result == RES_OK )
                ZVAL_LONG(zVPSessionID, (long)vpSessionID);
        RETURN_LONG((long)result);
}

/** VP 縺ｮ session 縺ｮ隧ｳ邏ｰ諠??ｱ繧貞ｾ励ｋ<br>
    int vp_get_session( int vp_session_id, array session_info )
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳ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 );
                freeSession( session );
        }
        
        RETURN_LONG((long)result);
}

/** 繝ｦ繝ｼ繧ｶ縺ｮactivate迥ｶ諷九ｒ蜿門ｾ励☆繧?lt;br>
    bool vp_is_activated( int vp_session_id, int user_id )
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param user_id  xoops_users.uid
    @return 0 success
  */
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);
}

/** activate縺吶ｋ縲?lt;br>
    bool vp_activate( int vp_session_id, int user_id, bool activated )
    @param vp_session_id   vp 縺ｮ session id
    @param user_id   xoops_users.uid
    @param activated  true:activate, false:inactivate
    @return 0 success
  */
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);
}

/** VP縺ｮ繧｢繧ｫ繧ｦ繝ｳ繝域焚繧貞ｾ励ｋ縲?lt;br>
    int vp_get_account_count( int vp_session_id )
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @return 0 success
  */
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);
}

/** 繧｢繧ｫ繧ｦ繝ｳ繝医ｒ蜑企勁縺吶ｋ縲?lt;br>
    bool vp_delete_account( int vp_session_id, int user_id )
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param user_id   xoops_users.uid
    @return 0 success
  */
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);
}

/** 繧｢繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ繧貞ｾ励ｋ縲?lt;br>
    int vp_get_account( int vp_session_id, int user_id, array account_info )
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param user_id   xoops_users.uid
    @param account_info 繧｢繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ繧貞女縺大叙繧矩?｣諠ｳ驟榊?
    @return 0 success
  */
ZEND_FUNCTION(vp_get_account)
{
        long sid, uid;
        zval *zaccount;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lla",
          &sid, &uid, &zaccount) == FAILURE) {
        fprintf( stderr, "error occured " );
                return;
        }
        
        const account_t *paccount;
        result_t result = getAccount( (sessionid_t)sid, (userid_t)uid, &paccount );
        if ( RES_OK == result ){
                accountToZval( paccount, zaccount );
                freeAccount( paccount );
        }
        
    RETURN_LONG(result);
}

/** 譚｡莉ｶ縺ｫ荳?閾ｴ縺吶ｋ繧｢繧ｫ繧ｦ繝ｳ繝医?諠??ｱ繧貞ｾ励ｋ縲?lt;br>
    int vp_get_accoutns( int sid, array uids, array criteria, array accounts );
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param user_id   xoops_users.uid
    @param criteria  蜿門ｾ礼ｯ?峇繝ｻ繧ｽ繝ｼ繝磯??ｒ陦ｨ縺咎?蛻?/span>
    @param account_info 繧｢繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ繧貞女縺大叙繧矩?｣諠ｳ驟榊?
    @return 0 success
  */
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 );
                                freeAccount( paccounts );
                        }
                }
        }
        
    RETURN_LONG(result);
}

/** 繧｢繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ繧定ｨ倬鹸縺吶ｋ縲?lt;br>
    int vp_insert_account( int sid, array account_info, int &user_id );
    @param vp_session_id   vp 縺ｮ session id
    @param account_info 險倬鹸縺励◆縺?い繧ｫ繧ｦ繝ｳ繝医?諠??ｱ
    @param user_id 繝ｦ繝ｼ繧ｶID(xoops_users.uid)繧呈嶌縺崎ｾｼ繧?繝ｪ繝輔ぃ繝ｬ繝ｳ繧ｹ
    @return 0 success
  */
ZEND_FUNCTION(vp_insert_account)
{
        result_t result;
        long sid;
        zval *zaccount;
        zval *zuid;
    userid_t uid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz",
          &sid, &zaccount, &zuid) == FAILURE) {
                return;
        }
        
        zAccount_t zacc(zaccount);
        result = zacc.getResult();
        if ( RES_OK == result ){
                result = insertAccount( (sessionid_t)sid, &zacc, &uid );
        }
    zuid -> type = IS_LONG;
    zuid -> value.lval = uid;
    RETURN_LONG(result);
}

/** 繧｢繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ繧呈峩譁ｰ縺吶ｋ縲?lt;br>
    int vp_update_account( int sid, array account );
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param account_info 譖ｸ縺崎ｾｼ繧?縺ｹ縺阪い繧ｫ繧ｦ繝ｳ繝域ュ蝣ｱ繧定｡ｨ縺咎?｣諠ｳ驟榊?
    @return 0 success
  */
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);
}

/** 譚｡莉ｶ縺ｫ蜷医≧繧｢繧ｫ繧ｦ繝ｳ繝医?uid縺ｮ荳?隕ｧ繧貞ｾ励ｋ縲?lt;br>
    int vp_dump_uids( int vp_session_id, array criteria, array uids );
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param criteria  蜿門ｾ礼ｯ?峇繝ｻ繧ｽ繝ｼ繝磯??ｒ陦ｨ縺咎?蛻?/span>
    @param uids uid繧貞女縺大叙繧矩?蛻?/span>
    @return 0 success
  */
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 );
                        freeUID( puid );
                }
        }
        
    RETURN_LONG(result);
}

/** VP縺ｮ繧ｰ繝ｫ繝ｼ繝励?謨ｰ繧貞ｾ励ｋ<br>
    int vp_get_group_count( int vp_session_id );
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @return 繧ｰ繝ｫ繝ｼ繝玲焚
  */
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);
}

/** uid縺ｧ謖?ｮ壹＠縺溘Θ繝ｼ繧ｶ縺悟ｱ槭☆繧ｰ繝ｫ繝ｼ繝励〒縲√°縺､譚｡莉ｶ縺ｫ荳?閾ｴ縺吶ｋ繧ｰ繝ｫ繝ｼ繝励?gid繧貞ｾ励ｋ<br>
    int vp_get_group_by_uid( int vp_session_id, int uid, array criteria, array gids );
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param user_id   xoops_users.uid
    @param criteria  蜿門ｾ礼ｯ?峇繝ｻ繧ｽ繝ｼ繝磯??ｒ陦ｨ縺咎?蛻?/span>
    @param gids gid繧貞女縺大叙繧矩?蛻?/span>
    @return 0 success
  */
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 );
                        freeGID( pgids );
                }
        }
        
    RETURN_LONG(result);
}


/** uid縺ｧ謖?ｮ壹＠縺溘Θ繝ｼ繧ｶ縺携id縺ｧ謖?ｮ壹＠縺溘げ繝ｫ繝ｼ繝励?繧ｰ繝ｫ繝ｼ繝礼ｮ｡逅???°縺ｩ縺?°繧貞ｾ励ｋ<br>
    int vp_is_group_admin( int sid, int gid, int uid );
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param group_id  VP縺ｮ繧ｰ繝ｫ繝ｼ繝悠D
    @param user_id   xoops_users.uid
    @return true: 繧ｰ繝ｫ繝ｼ繝礼ｮ｡逅???〒縺ゅｋ縲?/span>
    @return false: 繧ｰ繝ｫ繝ｼ繝礼ｮ｡逅???〒縺ｪ縺??ゅ≠繧九＞縺ｯ繧ｨ繝ｩ繝ｼ縺ｧ縺ゅｋ縲?/span>
  */
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);
}

/** 譚｡莉ｶ縺ｫ荳?閾ｴ縺吶ｋ繧ｰ繝ｫ繝ｼ繝励?gid縺ｮ荳?隕ｧ繧貞ｾ励ｋ縲?lt;br>
    int vp_dump_gids( int sid, array criteria, array gids );
    @param vp_session_id   VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param criteria  蜿門ｾ礼ｯ?峇繝ｻ繧ｽ繝ｼ繝磯??ｒ陦ｨ縺咎?蛻?/span>
    @param gids gid繧貞女縺大叙繧矩?蛻?/span>
    @return 0 success
  */
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 );
                        freeGID( pgid );
                }
        }
        
    RETURN_LONG(result);
}

/** gid縺ｧ謖?ｮ壹＠縺溘げ繝ｫ繝ｼ繝励?邂｡逅???〒縲√°縺､譚｡莉ｶ縺ｫ荳?閾ｴ縺吶ｋ繧ｰ繝ｫ繝ｼ繝礼ｮ｡逅????uid縺ｮ荳?隕ｧ繧貞ｾ励ｋ縲?lt;br>
    int vp_dump_group_admins(int sid, int group_id, array criteria, array uids )
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param group_id VP縺ｮ繧ｰ繝ｫ繝ｼ繝悠D
    @param criteria 譚｡莉ｶ
    @param uids     uid縺ｮ荳?隕ｧ繧貞女縺大叙繧矩?蛻?/span>
    @return 0 success 
  */

ZEND_FUNCTION(vp_dump_group_admins)
{
        long sid, gid;
        zval *zcriteria;
        zval *zuids;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa", 
                              &sid, &gid, &zcriteria, &zuids) == FAILURE) {
                return;
        }
        
        zCriteria_t zcri(zcriteria);
        result_t result = zcri.getResult();
        if ( result == RES_OK ){
                userid_t *uids;
                int uidsLen;
                result = dumpGroupAdmins( sid, gid, &zcri, &uids, &uidsLen );
                if ( result == RES_OK ){
                        uidsToZval( uids, uidsLen, &zuids );
                        freeUID( uids );
                }
        }
        RETURN_LONG( result );
}

/** 繧ｰ繝ｫ繝ｼ繝励°繧峨Γ繝ｳ繝舌?繧貞炎髯､縺吶ｋ縲?lt;br>
    int vp_delete_member(int sid, int group_id, int user_id )
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param group_id VP縺ｮ繧ｰ繝ｫ繝ｼ繝悠D
    @param user_id  繝ｦ繝ｼ繧ｶID
    @return 0 success 
  */

ZEND_FUNCTION(vp_delete_member)
{
        long sid, gid, uid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", 
                              &sid, &gid, &uid) == FAILURE) {
                return;
        }
        
        result_t result = deleteMember( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid );
        RETURN_LONG( result );
}

/** 繧ｰ繝ｫ繝ｼ繝励↓繝｡繝ｳ繝舌?繧定ｿｽ蜉?縺吶ｋ<br>
    int vp_insert_member(int sid, int group_id, int user_id, bool admin )
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param group_id VP縺ｮ繧ｰ繝ｫ繝ｼ繝悠D
    @param user_id  繝ｦ繝ｼ繧ｶID
    @param admin    繧ｰ繝ｫ繝ｼ繝礼ｮ｡逅???↑繧液rue
    @return 0 success 
  */

ZEND_FUNCTION(vp_insert_member)
{
        long sid, gid, uid;
        zend_bool admin;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllb", 
                              &sid, &gid, &uid, &admin) == FAILURE) {
                return;
        }
        
        result_t result = insertMember( (sessionid_t)sid, (groupid_t)gid, (userid_t)uid, (bool)admin );
        RETURN_LONG( result );
}

/** gid縺ｧ謖?ｮ壹＠縺溘げ繝ｫ繝ｼ繝励?繝｡繝ｳ繝舌?縺ｮuid縺ｮ荳?隕ｧ繧貞ｾ励ｋ<br>
    int vp_get_members(int sid, int group_id, array criteria, array uids )
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param group_id VP縺ｮ繧ｰ繝ｫ繝ｼ繝悠D
    @param criteria 譚｡莉ｶ
    @param uids     uid縺ｮ荳?隕ｧ繧貞女縺大叙繧矩?蛻?/span>
    @return 0 success 
  */

ZEND_FUNCTION(vp_get_members)
{
        long sid, gid;
        zval *zcriteria;
        zval *zuids;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa", 
                              &sid, &gid, &zcriteria, &zuids) == FAILURE) {
                return;
        }
        
        zCriteria_t zcri(zcriteria);
        result_t result = zcri.getResult();
        if ( result == RES_OK ){
                userid_t *uids;
                int uidsLen;
                result = getMembers( (sessionid_t)sid, (groupid_t)gid, &zcri, &uids, &uidsLen );
                if ( result == RES_OK ){
                        uidsToZval( uids, uidsLen, &zuids );
                        freeUID( uids );
                }
        }
        RETURN_LONG( result );
}

/** 繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ繧貞､画峩縺吶ｋ縲?lt;br>
    int vp_update_group(int sid, array group )
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param group    繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ縺ｮ騾｣諠ｳ驟榊?
    @return 0 success 
  */
ZEND_FUNCTION(vp_update_group)
{
        long sid;
        zval *zgroup;
    group_t group;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "la", 
                              &sid, &zgroup) == FAILURE) {
                return;
        }
        
    zvalToGroup( zgroup, &group );
    result_t result = updateGroup( sid, &group );
    RETURN_LONG( result );
}

/** 繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ繧定ｿｽ蜉?縺吶ｋ縲?lt;br>
    int vp_insert_group( int sid, array group, int &gid )
    @param sid      繧ｻ繝?す繝ｧ繝ｳID
    @param group    繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ縺ｮ騾｣諠ｳ驟榊?
    @param gid      蟇ｾ蠢懊☆繧九げ繝ｫ繝ｼ繝悠D繧呈嶌縺崎ｾｼ繧?繝ｪ繝輔ぃ繝ｬ繝ｳ繧ｹ
    @return RES_OK
    @return RES_DB_NOT_INITIALIZED
    @return RES_NO_SUCH_SESSION
    @return RES_DB_QUERY_ERROR
*/
ZEND_FUNCTION(vp_insert_group)
{
        long sid;
        zval *zgroup;
    zval *zgid;
    group_t group;
    groupid_t gid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "laz", 
                              &sid, &zgroup, &zgid ) == FAILURE) {
                return;
        }
        
    zvalToGroup( zgroup, &group );
    result_t result = insertGroup( sid, &group, &gid );
    zgid -> type = IS_LONG;
    zgid -> value.lval = gid;
    RETURN_LONG( result );
}


/** 繧ｰ繝ｫ繝ｼ繝玲ュ蝣ｱ繧貞炎髯､縺吶ｋ縲?lt;br>
    int vp_delete_group( int sid, int gid )
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param gid      蜑企勁縺励◆縺?げ繝ｫ繝ｼ繝励?ID
    @return RES_OK
    @return RES_DB_QUERY_ERROR
    @return RES_NO_SUCH_SESSION
    @return RES_DB_NOT_INITIALIZED
  */
ZEND_FUNCTION(vp_delete_group)
{
        long sid;
        long gid;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", 
                              &sid, &gid) == FAILURE) {
                return;
        }
    RETURN_LONG( deleteGroup( sid, gid ) );
}

/** 繧ｰ繝ｫ繝ｼ繝励?邂｡逅???ｒ蜿門ｾ励??lt;br>
    int vp_dump_group_admins( int sid, int gid, array criteria, array uids )
    @param sid      VP縺ｮ繧ｻ繝?す繝ｧ繝ｳID
    @param gid      VP繧ｰ繝ｫ繝ｼ繝励?ID
    @param criteria uids縺ｫ譖ｸ縺崎ｾｼ繧?縺ｨ縺阪?繧ｽ繝ｼ繝域擅莉ｶ?檎ｯ?峇縺ｮ謖?ｮ?/span>
    @param uids     邂｡逅????UID繧呈嶌縺崎ｾｼ繧?驟榊?
    @return RES_OK
    @return RES_DB_QUERY_ERROR
    @return RES_NO_SUCH_SESSION
    @return RES_DB_NOT_INITIALIZED
  */
/*
ZEND_FUNCTION(vp_dump_group_admins)
{
        long sid;
        long gid;
        zval *zcriteria;
        zval *zuids;
        
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "llaa", 
                              &sid, &gid, &zcriteria, &zuids) == FAILURE) {
                return;
        }
        zCriteria_t zcri(zcriteria);
        result_t result = zcri.getResult();
        if ( RES_OK == result ){
        userid_t* uids;
        int uidsLen;
        result_t result = dumpGroupAdmins( sid, gid, &zcri, &uids, &uidsLen );
        if( result != RES_OK ) RETURN_LONG( result );
        uidsToZval( uids, uidsLen, &zuids );
        fprintf( stderr, "uidsLen=%d\n", uidsLen );
        for( int i = 0; i < uidsLen; i++ ){
            fprintf( stderr, "%d, \n", uids[ i ] );
        }
        freeUID( uids );
        RETURN_LONG( result );
    }
    RETURN_LONG( result );
}
*/
    
/** VP縺ｮsession_id縺ｮ豁｣蠖捺?ｧ繝√ぉ繝?け<br>
    bool vp_is_valid_session_id( int vp_session_id)
    @return true 譛牙柑縺ｪVP縺ｮsession_id縺ｧ縺ゅｋ<br>
    @return false 辟｡蜉ｹ縺ｪsession_id縺ｾ縺溘?繧ｨ繝ｩ繝ｼ
  */
ZEND_FUNCTION(vp_is_valid_session_id)
{
        long sid;
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &sid ) == FAILURE) {
                return;
        }
        
        RETURN_BOOL(isValidSessionID((sessionid_t)sid));
}

/** 繧ｨ繝ｩ繝ｼ譁?ｭ怜?繧貞ｾ励ｋ<br>
    string vp_get_last_error_string()
    @return 0 success 
  */
ZEND_FUNCTION(vp_get_last_error_string)
{
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "" ) == FAILURE) {
                return;
        }
        
        string str( getLastErrorString() );
        RETURN_STRING((char *)str.c_str(), 1);
}
