Beispiel #1
0
/* Takes a pointer to posix group and a pointer to an already initialized ZVAL
 * array container and fills the array with the posix group member data. */
int php_posix_group_to_array(struct group *g, zval *array_group) /* {{{ */
{
	zval array_members;
	int count;

	if (NULL == g)
		return 0;

	if (array_group == NULL || Z_TYPE_P(array_group) != IS_ARRAY)
		return 0;

	array_init(&array_members);

	add_assoc_string(array_group, "name", g->gr_name);
	if (g->gr_passwd) {
		add_assoc_string(array_group, "passwd", g->gr_passwd);
	} else {
		add_assoc_null(array_group, "passwd");
	}
	for (count = 0; g->gr_mem[count] != NULL; count++) {
		add_next_index_string(&array_members, g->gr_mem[count]);
	}
	zend_hash_str_update(Z_ARRVAL_P(array_group), "members", sizeof("members")-1, &array_members);
	add_assoc_long(array_group, "gid", g->gr_gid);
	return 1;
}
Beispiel #2
0
static int full_user_list(struct user_info *uentp, struct fulluserlistarg* arg,int count)
{
    struct user_info userinfo=*uentp;
    struct userec *lookupuser;
    zval* element;
    if (!userinfo.active || !userinfo.pid) {
        return 0;
    }
    if (!HAS_PERM(getCurrentUser(), PERM_SEECLOAK) && userinfo.invisible && strcmp(userinfo.userid, getCurrentUser()->userid)) {
        /*Haohmaru.99.4.24.让隐身者能看见自己 */
        return 0;
    }
    if (count+1<arg->start)
        return COUNT;
    if (count+1-arg->start>=arg->num)
        return QUIT;
    MAKE_STD_ZVAL ( element );
    array_init ( element );

    add_assoc_bool ( element, "invisible", userinfo.invisible );
    add_assoc_long ( element, "pid", userinfo.pid );
    add_assoc_bool ( element, "isfriend", isfriend(userinfo.userid) );
    add_assoc_string ( element, "userid", userinfo.userid, 1 );
    add_assoc_string ( element, "username", userinfo.username, 1 );
    if( getuser(userinfo.userid, &lookupuser) == 0 ) lookupuser=NULL;
    add_assoc_string ( element, "userfrom", HAS_PERM(getCurrentUser(), PERM_SYSOP)? userinfo.from: SHOW_USERIP(lookupuser, userinfo.from), 1 );
    add_assoc_string ( element, "mode", ModeType(userinfo.mode), 1 );
    add_assoc_long ( element, "idle", (long)(time(0) - userinfo.freshtime)/60 );
    
    zend_hash_index_update(Z_ARRVAL_P(arg->return_value), count+1-arg->start, (void *) &element, sizeof(zval *), NULL);
    return COUNT;
}
Beispiel #3
0
static void _php_cal_info(int cal, zval **ret)
{
	zval *months, *smonths;
	int i;
	struct cal_entry_t *calendar;

	calendar = &cal_conversion_table[cal];
	array_init(*ret);

	MAKE_STD_ZVAL(months);
	MAKE_STD_ZVAL(smonths);
	array_init(months);
	array_init(smonths);

	for (i = 1; i <= calendar->num_months; i++) {
		add_index_string(months, i, calendar->month_name_long[i], 1);
		add_index_string(smonths, i, calendar->month_name_short[i], 1);
	}
	add_assoc_zval(*ret, "months", months);
	add_assoc_zval(*ret, "abbrevmonths", smonths);
	add_assoc_long(*ret, "maxdaysinmonth", calendar->max_days_in_month);
	add_assoc_string(*ret, "calname", calendar->name, 1);
	add_assoc_string(*ret, "calsymbol", calendar->symbol, 1);
	
}
/* {{{ MongoCursor->getCursorInfo: Return information about the current query (by @crodas)
 */
PHP_METHOD(MongoCursor, info)
{
  mongo_cursor *cursor = (mongo_cursor*)zend_object_store_get_object(getThis() TSRMLS_CC);
  MONGO_CHECK_INITIALIZED(cursor->link, MongoCursor);
  array_init(return_value);

  add_assoc_string(return_value, "ns", cursor->ns, 1);
  add_assoc_long(return_value, "limit", cursor->limit);
  add_assoc_long(return_value, "batchSize", cursor->batch_size);
  add_assoc_long(return_value, "skip", cursor->skip);
  if (cursor->query) {
    add_assoc_zval(return_value, "query", cursor->query);
    zval_add_ref(&cursor->query);
  } else {
    add_assoc_null(return_value, "query");
  }
  if (cursor->fields) {
    add_assoc_zval(return_value, "fields", cursor->fields);
    zval_add_ref(&cursor->fields);
  } else {
    add_assoc_null(return_value, "fields");
  }
    
  add_assoc_bool(return_value, "started_iterating", cursor->started_iterating);
  if (cursor->started_iterating) {
    add_assoc_long(return_value, "id", (long)cursor->cursor_id);
    add_assoc_long(return_value, "at", cursor->at);
    add_assoc_long(return_value, "numReturned", cursor->num);
    add_assoc_string(return_value, "server", cursor->server->label, 1);
  }
}
Beispiel #5
0
static int pdo_dblib_stmt_get_column_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value)
{
	pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
	pdo_dblib_db_handle *H = S->H;
	DBTYPEINFO* dbtypeinfo;

	if(colno >= stmt->column_count || colno < 0)  {
		return FAILURE;
	}

	array_init(return_value);

	dbtypeinfo = dbcoltypeinfo(H->link, colno+1);
	
	if(!dbtypeinfo) return FAILURE;
		
	add_assoc_long(return_value, "max_length", dbcollen(H->link, colno+1) );
	add_assoc_long(return_value, "precision", (int) dbtypeinfo->precision );
	add_assoc_long(return_value, "scale", (int) dbtypeinfo->scale );
	add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1));
	add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(dbcoltype(H->link, colno+1)));
	add_assoc_long(return_value, "native_type_id", dbcoltype(H->link, colno+1));
	add_assoc_long(return_value, "native_usertype_id", dbcolutype(H->link, colno+1));

	return 1;
}
Beispiel #6
0
void wkhtmltox_warning(wkhtmltopdf_converter *c, const char *msg) {
	zval *warning;
    	MAKE_STD_ZVAL(warning);
	array_init(warning);
	add_assoc_string(warning, "status", "warning", 1);
	add_assoc_string(warning, "message", (char *)msg, 1);
	add_next_index_zval(wkhtmltox_errorlog, warning);
}
Beispiel #7
0
static void bbs_make_vote_array(zval * array, struct votebal *vbal)
{
    add_assoc_string(array, "USERID", vbal->userid, 1);
    add_assoc_string(array, "TITLE", vbal->title, 1);
    add_assoc_long(array, "DATE", vbal->opendate);
    if(vbal->type <= 5 && vbal->type >= 1) add_assoc_string(array, "TYPE", vote_type[vbal->type-1], 1);
    add_assoc_long(array, "MAXDAY", vbal->maxdays);
}
Beispiel #8
0
void wkhtmltox_error(wkhtmltopdf_converter *c, const char *msg) {
	zval *error;
    	MAKE_STD_ZVAL(error);
	array_init(error);
	add_assoc_string(error, "status", "error", 1);
	add_assoc_string(error, "message", (char *)msg, 1);
	add_next_index_zval(wkhtmltox_errorlog, error);
}
Beispiel #9
0
/**
 * override __call()
 * it require two parameters, func_name and args
 **/
PHP_METHOD(McpackHessianClient, __call) {
	zend_class_entry *ce;
	zval *p_this, *args, *params, *result, *method, *tmp;
	char *func_name, *ret_str = NULL;
	int func_name_len = 0;
	size_t return_len = 0, max_len = 1024 * 1024 * 1024;

	p_this = getThis();
	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, p_this, 
		"Osz", &ce, mcphessian_ce_ptr, &func_name, &func_name_len, &args) == FAILURE) {
		php_error(E_WARNING, "parse parameters error.");
		RETURN_NULL();
	}

	// init params
	MAKE_STD_ZVAL(params);
	array_init(params);
	add_assoc_string(params, "jsonrpc", "2.0", 0);
	add_assoc_string(params, "method", func_name, 0);
	add_assoc_zval(params, "params", args);
	add_assoc_string(params, "id", "123456", 0);
	zval *pack = array2mcpack(params);

	// post data
	zval *z_url = zend_read_property(mcphessian_ce_ptr, p_this, ZEND_STRL("url"), 1 TSRMLS_CC);
	convert_to_string(z_url);
	char *url = Z_STRVAL_P(z_url);
	php_stream_context *context = php_stream_context_alloc();
	MAKE_STD_ZVAL(method);
	ZVAL_STRING(method, "POST", 0);
	php_stream_context_set_option(context, "http", "method", method);
	php_stream_context_set_option(context, "http", "content", pack);

	// read data from stream
	php_stream *stream = php_stream_open_wrapper_ex(url, "rb", REPORT_ERRORS, NULL, context);
	if (stream) {
		ret_str = php_stream_get_line(stream, NULL, max_len, &return_len);
	} else {
		php_error(E_WARNING, "failed to open stream %s.", url);
		RETURN_NULL();
	}
	MAKE_STD_ZVAL(tmp);
	ZVAL_STRINGL(tmp, ret_str, return_len, 0);
	result = mcpack2array(tmp);
	php_stream_close(stream);
	efree(ret_str);

	// get result from array
	zval **ret_val;
	if (zend_hash_exists(Z_ARRVAL_P(result), "result", 7)) {
		zend_hash_find(Z_ARRVAL_P(result), "result", 7, (void **)&ret_val);
		RETURN_ZVAL(*ret_val, 1, 0);
	} else {
		php_error(E_WARNING, "return value illegal.");
		RETURN_NULL();
	}
}
/* {{{ proto array accelerator_get_configuration()
   Obtain configuration information */
static ZEND_FUNCTION(opcache_get_configuration)
{
	zval directives, version, blacklist;

	if (zend_parse_parameters_none() == FAILURE) {
		RETURN_FALSE;
	}

	if (!validate_api_restriction()) {
		RETURN_FALSE;
	}

	array_init(return_value);

	/* directives */
	array_init(&directives);
	add_assoc_bool(&directives, "opcache.enable",              ZCG(enabled));
	add_assoc_bool(&directives, "opcache.enable_cli",          ZCG(accel_directives).enable_cli);
	add_assoc_bool(&directives, "opcache.use_cwd",             ZCG(accel_directives).use_cwd);
	add_assoc_bool(&directives, "opcache.validate_timestamps", ZCG(accel_directives).validate_timestamps);
	add_assoc_bool(&directives, "opcache.inherited_hack",      ZCG(accel_directives).inherited_hack);
	add_assoc_bool(&directives, "opcache.dups_fix",            ZCG(accel_directives).ignore_dups);
	add_assoc_bool(&directives, "opcache.revalidate_path",     ZCG(accel_directives).revalidate_path);

	add_assoc_long(&directives,   "opcache.log_verbosity_level",    ZCG(accel_directives).log_verbosity_level);
	add_assoc_long(&directives,	 "opcache.memory_consumption",     ZCG(accel_directives).memory_consumption);
	add_assoc_long(&directives,	 "opcache.interned_strings_buffer",ZCG(accel_directives).interned_strings_buffer);
	add_assoc_long(&directives, 	 "opcache.max_accelerated_files",  ZCG(accel_directives).max_accelerated_files);
	add_assoc_double(&directives, "opcache.max_wasted_percentage",  ZCG(accel_directives).max_wasted_percentage);
	add_assoc_long(&directives, 	 "opcache.consistency_checks",     ZCG(accel_directives).consistency_checks);
	add_assoc_long(&directives, 	 "opcache.force_restart_timeout",  ZCG(accel_directives).force_restart_timeout);
	add_assoc_long(&directives, 	 "opcache.revalidate_freq",        ZCG(accel_directives).revalidate_freq);
	add_assoc_string(&directives, "opcache.preferred_memory_model", STRING_NOT_NULL(ZCG(accel_directives).memory_model));
	add_assoc_string(&directives, "opcache.blacklist_filename",     STRING_NOT_NULL(ZCG(accel_directives).user_blacklist_filename));
	add_assoc_long(&directives,   "opcache.max_file_size",          ZCG(accel_directives).max_file_size);
	add_assoc_string(&directives, "opcache.error_log",              STRING_NOT_NULL(ZCG(accel_directives).error_log));

	add_assoc_bool(&directives,   "opcache.protect_memory",         ZCG(accel_directives).protect_memory);
	add_assoc_bool(&directives,   "opcache.save_comments",          ZCG(accel_directives).save_comments);
	add_assoc_bool(&directives,   "opcache.load_comments",          ZCG(accel_directives).load_comments);
	add_assoc_bool(&directives,   "opcache.fast_shutdown",          ZCG(accel_directives).fast_shutdown);
	add_assoc_bool(&directives,   "opcache.enable_file_override",   ZCG(accel_directives).file_override_enabled);
	add_assoc_long(&directives, 	 "opcache.optimization_level",     ZCG(accel_directives).optimization_level);

	add_assoc_zval(return_value, "directives", &directives);

	/*version */
	array_init(&version);
	add_assoc_string(&version, "version", ACCELERATOR_VERSION);
	add_assoc_string(&version, "opcache_product_name", ACCELERATOR_PRODUCT_NAME);
	add_assoc_zval(return_value, "version", &version);

	/* blacklist */
	array_init(&blacklist);
	zend_accel_blacklist_apply(&accel_blacklist, add_blacklist_path, &blacklist);
	add_assoc_zval(return_value, "blacklist", &blacklist);
}
/**
 * Internal function that goes through every property specified in the PHP.ini
 * file and for each of the properties checks that such property exists in the
 * data set properties array. If a property exists, then a corresponding value
 * is added to the array that will be returned to PHP. If a property does not
 * exist, then a "Switch Data Set" message is returned as the property value
 * @param returnArray a pointer to the Zend array to store results in.
 */
void buildArray(zval *returnArray)
{
    char* propertyName;
    char *valueString;
    char* methodString;
    int propertyIndex;
    int valueCount;
    int valueIndex;
    int32_t sigRank;

    for(propertyIndex = 0;
        propertyIndex < FIFTYONE_G(ws)->dataSet->requiredPropertyCount;
        propertyIndex++) {
        propertyName = (char*)fiftyoneDegreesGetPropertyName(
                FIFTYONE_G(ws)->dataSet,
                *(FIFTYONE_G(ws)->dataSet->requiredProperties + propertyIndex));
        valueCount = fiftyoneDegreesSetValues(FIFTYONE_G(ws), propertyIndex);

        if (valueCount == 1) {
            valueString = (char*)fiftyoneDegreesGetValueName(
                FIFTYONE_G(ws)->dataSet,
                *FIFTYONE_G(ws)->values);
            add_assoc_string(returnArray, propertyName, valueString, 1);
        } else if (valueCount > 1) {
            zval* valueArray;
            ALLOC_INIT_ZVAL(valueArray);
            array_init(valueArray);
            add_assoc_zval(returnArray, propertyName, valueArray);
            for(valueIndex = 0; valueIndex < valueCount; valueIndex++) {
                valueString = (char*)fiftyoneDegreesGetValueName(
                    FIFTYONE_G(ws)->dataSet,
                    *(FIFTYONE_G(ws)->values + valueIndex));
                add_next_index_string(valueArray, valueString, 1);
            }
        }
    }
    // Add signature rank information.
    sigRank = fiftyoneDegreesGetSignatureRank(FIFTYONE_G(ws));
    // SignatureRank is obsolete and will be removed in future versions.
    // Use Rank instead.
    add_assoc_long(returnArray, "SignatureRank", sigRank);
    add_assoc_long(returnArray, "Rank", sigRank);
    add_assoc_long(returnArray, "Difference", FIFTYONE_G(ws)->difference);

    // Add method that was used for detection to the results array.
    switch(FIFTYONE_G(ws)->method){
        case NONE: methodString = "None"; break;
        case EXACT: methodString = "Exact"; break;
        case NUMERIC: methodString = "Numeric"; break;
        case NEAREST: methodString = "Nearest"; break;
        case CLOSEST: methodString = "Closest"; break;
        default: methodString = "Unknown"; break;
    }
    add_assoc_string(returnArray, "Method", methodString, 1);
    addDeviceIdToArray(returnArray);
}
Beispiel #12
0
/****
 * add by stiger, template, 摸板
 */
static void bbs_make_tmpl_array(zval * array, struct a_template * ptemp, char *board)
{
    add_assoc_string(array, "TITLE", ptemp->tmpl->title, 1);
    add_assoc_string(array, "TITLE_TMPL", ptemp->tmpl->title_tmpl, 1);
    add_assoc_long(array, "CONT_NUM", ptemp->tmpl->content_num);
	if( ptemp->tmpl->filename[0] ){
		char path[STRLEN];
		setbfile( path, board, ptemp->tmpl->filename );
    	add_assoc_string(array, "FILENAME", path,1);
	}else
 		add_assoc_string(array, "FILENAME", ptemp->tmpl->filename,1);
}
Beispiel #13
0
static void bbs_make_user_vote_array(zval * array, struct ballot *vbal)
{
	if(vbal && vbal->uid[0]){
	    add_assoc_string(array, "USERID", vbal->uid, 1);
    	add_assoc_long(array, "VOTED", vbal->voted);
	    add_assoc_string(array, "MSG1", vbal->msg[0], 1);
	    add_assoc_string(array, "MSG2", vbal->msg[1], 1);
	    add_assoc_string(array, "MSG3", vbal->msg[2], 1);
	}else{
	    add_assoc_string(array, "USERID", "", 1);
	}
}
Beispiel #14
0
static void
describe_dict_fn (const char * const lang,
                  const char * const name,
                  const char * const desc,
                  const char * const file,
                  void * ud) /* {{{ */
{
	zval *zdesc = (zval *) ud;
	array_init(zdesc);
	add_assoc_string(zdesc, "lang", (char *)lang, 1);
	add_assoc_string(zdesc, "name", (char *)name, 1);
	add_assoc_string(zdesc, "desc", (char *)desc, 1);
	add_assoc_string(zdesc, "file", (char *)file, 1);
}
Beispiel #15
0
/* {{{ QConfig::GetBatchConf( .. )
   */
static PHP_METHOD(QConfig, GetBatchConf)
{
	char *path, *idc;
	size_t path_len, idc_len;
	int i;
	qconf_batch_nodes bnodes;
	long get_flags = QCONF_WAIT;
	int ret = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|sl", &path, &path_len, &idc, &idc_len, &get_flags) == FAILURE) 
	{
		RETURN_NULL();
	}
    
	init_qconf_batch_nodes(&bnodes);
	if (QCONF_OK != ret)
	{
		RETVAL_NULL();
	}

	if (QCONF_NOWAIT == get_flags)
	{
		ret = qconf_aget_batch_conf(path, &bnodes, idc);
	}
	else
	{
		ret = qconf_get_batch_conf(path, &bnodes, idc); 
	}

	if (QCONF_OK == ret && (bnodes.count >= 0))
	{
		array_init(return_value);
		for (i = 0; i < bnodes.count; i++) 
		{
#if PHP_VERSION_ID >= 70000
			add_assoc_string(return_value, bnodes.nodes[i].key, bnodes.nodes[i].value);
#else
			add_assoc_string(return_value, bnodes.nodes[i].key, bnodes.nodes[i].value, 1);
#endif
		}

		destroy_qconf_batch_nodes(&bnodes);
	}
	else
	{
		RETVAL_NULL();
	}

	return;
}
void CACHE_COLL::serialize_php(zval *zcolllist)
{
  zval *zcoll;
	MAKE_STD_ZVAL(zcoll);
	array_init(zcoll);
	add_assoc_long(zcoll, (char *)"coll_id", this->coll_id);
	add_assoc_long(zcoll, (char *)"base_id", this->base_id);
	add_assoc_string(zcoll, (char *)"name", this->name, true);
#if GETPREFS
	add_assoc_string(zcoll, (char *)"prefs", this->prefs, true);
#endif
//	add_assoc_bool(zcoll, (char *)"registered", this->registered);
	add_next_index_zval(zcolllist, zcoll);
}
Beispiel #17
0
static void bbs_make_detail_tmpl_array(zval * array, struct s_content * cont)
{

    add_assoc_string(array, "TEXT", cont->text, 1);
    add_assoc_long(array, "LENGTH", cont->length);

}
Beispiel #18
0
int php_posix_passwd_to_array(struct passwd *pw, zval *return_value) /* {{{ */
{
	if (NULL == pw)
		return 0;
	if (NULL == return_value || Z_TYPE_P(return_value) != IS_ARRAY)
		return 0;

	add_assoc_string(return_value, "name",      pw->pw_name);
	add_assoc_string(return_value, "passwd",    pw->pw_passwd);
	add_assoc_long  (return_value, "uid",       pw->pw_uid);
	add_assoc_long  (return_value, "gid",		pw->pw_gid);
	add_assoc_string(return_value, "gecos",     pw->pw_gecos);
	add_assoc_string(return_value, "dir",       pw->pw_dir);
	add_assoc_string(return_value, "shell",     pw->pw_shell);
	return 1;
}
Beispiel #19
0
/*
 * plphp_zval_from_tuple
 *		 Build a PHP hash from a tuple.
 */
zval *
plphp_zval_from_tuple(HeapTuple tuple, TupleDesc tupdesc)
{
	int			i;
	char	   *attname = NULL;
	zval	   *array;

	MAKE_STD_ZVAL(array);
	array_init(array);

	for (i = 0; i < tupdesc->natts; i++)
	{
		char *attdata;

		/* Get the attribute name */
		attname = tupdesc->attrs[i]->attname.data;

		/* and get its value */
		if ((attdata = SPI_getvalue(tuple, tupdesc, i + 1)) != NULL)
		{
			/* "true" means strdup the string */
			add_assoc_string(array, attname, attdata, true);
			pfree(attdata);
		}
		else
			add_assoc_null(array, attname);
	}
	return array;
}
static PHP_METHOD(midgard_key_config_context, list_key_config)
{
	RETVAL_FALSE;
	zval *zval_object = getThis();

	if (zend_parse_parameters_none() == FAILURE)
		return;

	MidgardKeyConfigContext *kctx = (MidgardKeyConfigContext *) __php_gobject_ptr(zval_object);

	array_init (return_value);

	gint n_cfgs;
	gchar **cfgs = midgard_key_config_context_list_key_config (kctx, &n_cfgs);

	if (!cfgs)
		return;

	guint i;
	for (i = 0; i < n_cfgs; i++) {

		add_assoc_string(return_value, (gchar *)cfgs[i], "", 1);
	}

        g_strfreev(cfgs);
}
Beispiel #21
0
static PHP_METHOD(Hello, addProperties) {
    zval *obj;
    obj = getThis();

    /*add zval property*/
    zval *arr;
    MAKE_STD_ZVAL(arr);
    array_init(arr);
    add_assoc_string(arr, "e", "hello", 1);
    add_index_string(arr, 1, "hello1111", 1);
    add_property_zval_ex(obj, "persons", strlen("persons")+1, arr TSRMLS_CC);
    Z_DELREF_P(arr);


    /*add double property*/
    add_property_double(obj, "d", 10.5);

    /*add bool property*/
    add_property_bool(obj, "b", 1);

    /*add string property*/
    char *str = "hello str";
    add_property_string(obj, "str", str, 1);
    
    /*add long property*/
    add_property_long(obj, "l", 12);
}
Beispiel #22
0
ZEND_METHOD( appnetServer , getHeader )
{
	array_init(return_value);
	aeServer* appserv = APPNET_G( appserv );

	int i;
	int connfd = appserv->worker->connfd;
	httpHeader* header = &appserv->connlist[connfd].hh;
	if( header->protocol == HTTP )
	{
	add_assoc_string(return_value, "Protocol" , "HTTP" );
	}
	else if(  header->protocol == WEBSOCKET )
	{
		 add_assoc_string(return_value, "Protocol" , "WEBSOCKET" );
	}
	else
	{
	add_assoc_string(return_value, "Protocol" , "TCP" );
	return;
	}
	add_assoc_string(return_value, "Method" , header->method );
	add_assoc_string(return_value, "Uri" , header->uri );
	add_assoc_string(return_value, "Version" , header->version );

	for( i = 0 ; i < header->filed_nums ; i++ )
	{
	add_assoc_string(return_value, header->fileds[i].key  , header->fileds[i].value  );
	}
}
Beispiel #23
0
PHP_METHOD(MongoDB, getReadPreference)
{
    mongo_db *db;
    PHP_MONGO_GET_DB(getThis());

    array_init(return_value);
    add_assoc_string(return_value, "type", mongo_read_preference_type_to_name(db->read_pref.type), 1);
    php_mongo_add_tagsets(return_value, &db->read_pref);
}
Beispiel #24
0
static void bbs_make_detail_vote_array(zval * array, struct votebal *vbal)
{
	int i;
	char tmp[10];

    add_assoc_string(array, "USERID", vbal->userid, 1);
    add_assoc_string(array, "TITLE", vbal->title, 1);
    add_assoc_long(array, "DATE", vbal->opendate);
    if(vbal->type <= 5 && vbal->type >= 1) add_assoc_string(array, "TYPE", vote_type[vbal->type-1], 1);
    add_assoc_long(array, "MAXDAY", vbal->maxdays);
    add_assoc_long(array, "MAXTKT", vbal->maxtkt);
    add_assoc_long(array, "TOTALITEMS", vbal->totalitems);

	for(i=0; i < vbal->totalitems; i++){
		sprintf(tmp,"ITEM%d",i+1);
		add_assoc_string(array, tmp, vbal->items[i], 1);
	}

}
Beispiel #25
0
static void php_enchant_list_dicts_fn( const char * const lang_tag,
	   	const char * const provider_name, const char * const provider_desc,
		const char * const provider_file, void * ud) /* {{{ */
{
	zval *zdesc = (zval *) ud;
	zval tmp_array;

	array_init(&tmp_array);
	add_assoc_string(&tmp_array, "lang_tag", (char *)lang_tag);
	add_assoc_string(&tmp_array, "provider_name", (char *)provider_name);
	add_assoc_string(&tmp_array, "provider_desc", (char *)provider_desc);
	add_assoc_string(&tmp_array, "provider_file", (char *)provider_file);

	if (Z_TYPE_P(zdesc) != IS_ARRAY) {
		array_init(zdesc);
	}
	add_next_index_zval(zdesc, &tmp_array);

}
/**
 * Adds a new element to the array with the key Id and the value as the device
 * Id.
 * @param returnArray the array being built
 */
void addDeviceIdToArray(zval *returnArray) {
    int componentIndex;
    int bufferLength = FIFTYONE_G(ws)->dataSet->header.components.count * 10;
    char *buffer = (char *)malloc(bufferLength * sizeof(char));
    if (buffer != NULL) {
        fiftyoneDegreesGetDeviceId(FIFTYONE_G(ws), buffer, bufferLength);
        add_assoc_string(returnArray, "Id", buffer, 1);
        free(buffer);
    }
}
PHP_METHOD(MongoCollection, getReadPreference)
{
	mongo_collection *c;
	PHP_MONGO_GET_COLLECTION(getThis());

	array_init(return_value);
	add_assoc_long(return_value, "type", c->read_pref.type);
	add_assoc_string(return_value, "type_string", mongo_read_preference_type_to_name(c->read_pref.type), 1);
	php_mongo_add_tagsets(return_value, &c->read_pref);
}
static void add_expr_to_array(zval *expressions, uri_template_expr *expr)
{
	uri_template_var *next;
	zval *result;
	zval *vars;
	char op[2] = {expr->op, 0};
	char sep[2] = {expr->sep, 0};
	char ifemp[2] = {expr->ifemp, 0};
	
	MAKE_STD_ZVAL(result);
	array_init(result);
	
	add_assoc_string(result, "op", op, 1);
	add_assoc_string(result, "sep", sep, 1);
	add_assoc_string(result, "ifemp", ifemp, 1);
	add_assoc_bool(result, "allow", expr->allow);
	add_assoc_bool(result, "named", expr->named);
	add_assoc_bool(result, "error", expr->error);
	
	MAKE_STD_ZVAL(vars);
	array_init_size(vars, expr->vars->count);
	
	next = expr->vars->first;
	
	while (next != NULL) {
		zval *var;
		
		MAKE_STD_ZVAL(var);
		array_init(var);
		
		add_assoc_string(var, "name", next->name, 1);
		add_assoc_long(var, "length", next->length);
		add_assoc_bool(var, "explode", next->explode);
		add_next_index_zval(vars, var);
		
		next = next->next;
	}
	
	add_assoc_zval(result, "vars", vars);
	add_next_index_zval(expressions, result);
}
Beispiel #29
0
static int pdo_dblib_stmt_get_column_meta(pdo_stmt_t *stmt, zend_long colno, zval *return_value)
{
	pdo_dblib_stmt *S = (pdo_dblib_stmt*)stmt->driver_data;
	pdo_dblib_db_handle *H = S->H;
	DBTYPEINFO* dbtypeinfo;
	int coltype;

	if(colno >= stmt->column_count || colno < 0)  {
		return FAILURE;
	}

	array_init(return_value);

	dbtypeinfo = dbcoltypeinfo(H->link, colno+1);

	if(!dbtypeinfo) return FAILURE;

	coltype = dbcoltype(H->link, colno+1);

	add_assoc_long(return_value, "max_length", dbcollen(H->link, colno+1) );
	add_assoc_long(return_value, "precision", (int) dbtypeinfo->precision );
	add_assoc_long(return_value, "scale", (int) dbtypeinfo->scale );
	add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1));
	add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(coltype));
	add_assoc_long(return_value, "native_type_id", coltype);
	add_assoc_long(return_value, "native_usertype_id", dbcolutype(H->link, colno+1));

	switch (coltype) {
		case SQLBIT:
		case SQLINT1:
		case SQLINT2:
		case SQLINT4:
			add_assoc_long(return_value, "pdo_type", PDO_PARAM_INT);
			break;
		default:
			add_assoc_long(return_value, "pdo_type", PDO_PARAM_STR);
			break;
	}

	return 1;
}
Beispiel #30
0
static void
enumerate_providers_fn (const char * const name,
                        const char * const desc,
                        const char * const file,
                        void * ud) /* {{{ */
{
	zval *zdesc = (zval *) ud;
	zval tmp_array;

	array_init(&tmp_array);

	add_assoc_string(&tmp_array, "name", (char *)name);
	add_assoc_string(&tmp_array, "desc", (char *)desc);
	add_assoc_string(&tmp_array, "file", (char *)file);

	if (Z_TYPE_P(zdesc)!=IS_ARRAY) {
		array_init(zdesc);
	}

	add_next_index_zval(zdesc, &tmp_array);
}