Exemplo n.º 1
0
static int php_password_make_salt(size_t length, char *ret) /* {{{ */
{
    size_t raw_length;
    char *buffer;
    char *result;

    if (length > (INT_MAX / 3)) {
        php_error_docref(NULL, E_WARNING, "Length is too large to safely generate");
        return FAILURE;
    }

    raw_length = length * 3 / 4 + 1;

    buffer = (char *) safe_emalloc(raw_length, 1, 1);

    if (FAILURE == php_random_bytes_silent(buffer, raw_length)) {
        php_error_docref(NULL, E_WARNING, "Unable to generate salt");
        efree(buffer);
        return FAILURE;
    }

    result = safe_emalloc(length, 1, 1);
    if (php_password_salt_to64(buffer, raw_length, length, result) == FAILURE) {
        php_error_docref(NULL, E_WARNING, "Generated salt too short");
        efree(buffer);
        efree(result);
        return FAILURE;
    }
    memcpy(ret, result, length);
    efree(result);
    efree(buffer);
    ret[length] = 0;
    return SUCCESS;
}
Exemplo n.º 2
0
/* {{{ reference_levdist
 * reference implementation, only optimized for memory usage, not speed */
static zend_long reference_levdist(const char *s1, size_t l1, const char *s2, size_t l2, zend_long cost_ins, zend_long cost_rep, zend_long cost_del )
{
	zend_long *p1, *p2, *tmp;
	zend_long c0, c1, c2;
	size_t i1, i2;

	if (l1 == 0) {
		return l2 * cost_ins;
	}
	if (l2 == 0) {
		return l1 * cost_del;
	}

	if ((l1 > LEVENSHTEIN_MAX_LENGTH) || (l2 > LEVENSHTEIN_MAX_LENGTH)) {
		return -1;
	}
	p1 = safe_emalloc((l2 + 1), sizeof(zend_long), 0);
	p2 = safe_emalloc((l2 + 1), sizeof(zend_long), 0);

	for (i2 = 0; i2 <= l2; i2++) {
		p1[i2] = i2 * cost_ins;
	}
	for (i1 = 0; i1 < l1 ; i1++) {
		p2[0] = p1[0] + cost_del;

		for (i2 = 0; i2 < l2; i2++) {
			c0 = p1[i2] + ((s1[i1] == s2[i2]) ? 0 : cost_rep);
			c1 = p1[i2 + 1] + cost_del;
			if (c1 < c0) {
				c0 = c1;
			}
			c2 = p2[i2] + cost_ins;
			if (c2 < c0) {
				c0 = c2;
			}
			p2[i2 + 1] = c0;
		}
		tmp = p1;
		p1 = p2;
		p2 = tmp;
	}
	c0 = p1[l2];

	efree(p1);
	efree(p2);

	return c0;
}
Exemplo n.º 3
0
static int com_call_method(zend_string *method, zend_object *object, INTERNAL_FUNCTION_PARAMETERS)
{
	zval *args = NULL;
	php_com_dotnet_object *obj = (php_com_dotnet_object*)object;
	int nargs;
	VARIANT v;
	int ret = FAILURE;

	if (V_VT(&obj->v) != VT_DISPATCH) {
		return FAILURE;
	}

	nargs = ZEND_NUM_ARGS();

	if (nargs) {
		args = (zval *)safe_emalloc(sizeof(zval), nargs, 0);
		zend_get_parameters_array_ex(nargs, args);
	}

	VariantInit(&v);

	if (SUCCESS == php_com_do_invoke_byref(obj, (zend_internal_function*)EX(func), DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, nargs, args)) {
		php_com_zval_from_variant(return_value, &v, obj->code_page);
		ret = SUCCESS;
		VariantClear(&v);
	}

	if (args) {
		efree(args);
	}

	return ret;
}
Exemplo n.º 4
0
zend_object_iterator *php_com_saproxy_iter_get(zend_class_entry *ce, zval *object, int by_ref)
{
	php_com_saproxy *proxy = SA_FETCH(object);
	php_com_saproxy_iter *I;
	int i;

	if (by_ref) {
		zend_throw_error(NULL, "An iterator cannot be used with foreach by reference");
		return NULL;
	}

	I = ecalloc(1, sizeof(*I));
	I->iter.funcs = &saproxy_iter_funcs;
	Z_PTR(I->iter.data) = I;

	I->proxy = proxy;
	ZVAL_COPY(&I->proxy_obj, object);

	I->indices = safe_emalloc(proxy->dimensions + 1, sizeof(LONG), 0);
	for (i = 0; i < proxy->dimensions; i++) {
		convert_to_long(&proxy->indices[i]);
		I->indices[i] = (LONG)Z_LVAL(proxy->indices[i]);
	}

	SafeArrayGetLBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &I->imin);
	SafeArrayGetUBound(V_ARRAY(&proxy->obj->v), proxy->dimensions, &I->imax);

	I->key = I->imin;

	return &I->iter;
}
Exemplo n.º 5
0
static inline void *accounted_safe_ecalloc(size_t nmemb, size_t alloc_size, size_t offset, ser_context *ctx)
{
	void *ret = safe_emalloc(nmemb, alloc_size, offset);
	memset(ret, '\0', nmemb * alloc_size + offset);
	zend_llist_add_element(&ctx->allocations, &ret);
	return ret;
}
Exemplo n.º 6
0
static void php_hash_do_hash(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
{
	char *algo, *data, *digest;
	int algo_len, data_len;
	zend_bool raw_output = raw_output_default;
	const php_hash_ops *ops;
	void *context;
	php_stream *stream = NULL;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &algo, &algo_len, &data, &data_len, &raw_output) == FAILURE) {
		return;
	}

	ops = php_hash_fetch_ops(algo, algo_len);
	if (!ops) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown hashing algorithm: %s", algo);
		RETURN_FALSE;
	}
	if (isfilename) {
		if (CHECK_NULL_PATH(data, data_len)) {
			RETURN_FALSE;
		}
		stream = php_stream_open_wrapper_ex(data, "rb", REPORT_ERRORS, NULL, DEFAULT_CONTEXT);
		if (!stream) {
			/* Stream will report errors opening file */
			RETURN_FALSE;
		}
	}

	context = emalloc(ops->context_size);
	ops->hash_init(context);

	if (isfilename) {
		char buf[1024];
		int n;

		while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
			ops->hash_update(context, (unsigned char *) buf, n);
		}
		php_stream_close(stream);
	} else {
		ops->hash_update(context, (unsigned char *) data, data_len);
	}

	digest = emalloc(ops->digest_size + 1);
	ops->hash_final((unsigned char *) digest, context);
	efree(context);

	if (raw_output) {
		digest[ops->digest_size] = 0;
		RETURN_STRINGL(digest, ops->digest_size, 0);
	} else {
		char *hex_digest = safe_emalloc(ops->digest_size, 2, 1);

		php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size);
		hex_digest[2 * ops->digest_size] = 0;
		efree(digest);
		RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0);
	}
}
Exemplo n.º 7
0
void php_filter_callback(PHP_INPUT_FILTER_PARAM_DECL)
{
	zval retval;
	zval *args;
	int status;

	if (!option_array || !zend_is_callable(option_array, IS_CALLABLE_CHECK_NO_ACCESS, NULL TSRMLS_CC)) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argument is expected to be a valid callback");
		zval_ptr_dtor(value);
		ZVAL_NULL(value);
		return;
	}

	args = safe_emalloc(sizeof(zval), 1, 0);
	ZVAL_COPY(&args[0], value);
	status = call_user_function_ex(EG(function_table), NULL, option_array, &retval, 1, args, 0, NULL TSRMLS_CC);

	if (status == SUCCESS && !Z_ISUNDEF(retval)) {
		zval_ptr_dtor(value);
		ZVAL_COPY_VALUE(value, &retval);
	} else {
		zval_ptr_dtor(value);
		ZVAL_NULL(value);
	}

	zval_ptr_dtor(&args[0]);
	efree(args);
}
Exemplo n.º 8
0
/* {{{ _timecop_call_mktime - timecop_(gm)mktime helper */
static void _timecop_call_mktime(INTERNAL_FUNCTION_PARAMETERS, const char *mktime_function_name, const char *date_function_name)
{
	zval *params;
	uint32_t param_count;

	int i;

	param_count = MAX(ZEND_NUM_ARGS(), MKTIME_NUM_ARGS);
	params = (zval *)safe_emalloc(param_count, sizeof(zval), 0);

	if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), params) == FAILURE) {
		efree(params);
		zend_throw_error(NULL, "Cannot get arguments for calling");
		return;
	}

	param_count = ZEND_NUM_ARGS();
	if (param_count < MKTIME_NUM_ARGS) {
		fill_mktime_params(params, date_function_name, param_count);
		param_count = MKTIME_NUM_ARGS;
	}

	if (ZEND_NUM_ARGS() == 0) {
		php_error_docref(NULL, E_STRICT, "You should be using the time() function instead");
	}

	simple_call_function(mktime_function_name, return_value, param_count, params);

	for (i = ZEND_NUM_ARGS(); i < MKTIME_NUM_ARGS; i++) {
		zval_ptr_dtor(&params[i]);
	}
	efree(params);
}
Exemplo n.º 9
0
/* {{{ proto TimecopDateTime::__construct([string time[, DateTimeZone object]])
   Creates new TimecopDateTime object
*/
PHP_METHOD(TimecopDateTime, __construct)
{
	zval *params;
	zval *obj = getThis();

	params = (zval *)safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval), 0);

	if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), params) == FAILURE) {
		efree(params);
		zend_throw_error(NULL, "Cannot get arguments for TimecopDateTime::__construct");
		RETURN_FALSE;
	}

	/* call original DateTime::__construct() */
	timecop_call_original_constructor(obj, TIMECOP_G(ce_DateTime), params, ZEND_NUM_ARGS());

	if (!EG(exception)) {
		zval *time = NULL, *timezone_obj = NULL;
		if (ZEND_NUM_ARGS() >= 1) {
			time = &params[0];
		}
		if (ZEND_NUM_ARGS() >= 2) {
			timezone_obj = &params[1];
		}
		fix_datetime_timestamp(obj, time, timezone_obj);
	}

	efree(params);
}
Exemplo n.º 10
0
void php_filter_callback(PHP_INPUT_FILTER_PARAM_DECL)
{
    zval *retval_ptr;
    zval ***args;
    int status;

    if (!option_array || !zend_is_callable(option_array, IS_CALLABLE_CHECK_NO_ACCESS, NULL TSRMLS_CC)) {
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "First argument is expected to be a valid callback");
        zval_dtor(value);
        Z_TYPE_P(value) = IS_NULL;
        return;
    }

    args = safe_emalloc(sizeof(zval **), 1, 0);
    args[0] = &value;

    status = call_user_function_ex(EG(function_table), NULL, option_array, &retval_ptr, 1, args, 0, NULL TSRMLS_CC);

    if (status == SUCCESS && retval_ptr != NULL) {
        if (retval_ptr != value) {
            zval_dtor(value);
            COPY_PZVAL_TO_ZVAL(*value, retval_ptr);
        } else {
            zval_ptr_dtor(&retval_ptr);
        }
    } else {
        zval_dtor(value);
        Z_TYPE_P(value) = IS_NULL;
    }

    efree(args);
}
Exemplo n.º 11
0
char *str_repeat(const char *input_str, int len)
{
    char *result;
    size_t result_len;

    if (input_str == NULL)
        return NULL;
    if (len <= 0)
        return "";

    result_len = strlen(input_str) * len;
    result = (char *)safe_emalloc(strlen(input_str), len, 1);

    /* Heavy optimization for situations where input string is 1 byte long */
    if (strlen(input_str) == 1) {
        memset(result, *(input_str), len);
    } else {
        char *s, *e, *ee;
        int l=0;
        memcpy(result, input_str, strlen(input_str));
        s = result;
        e = result + strlen(input_str);
        ee = result + result_len;

        while (e<ee) {
            l = (e-s) < (ee-e) ? (e-s) : (ee-e);
            memmove(e, s, l);
            e += l;
        }
    }

    result[result_len] = '\0';
    return result;
}
Exemplo n.º 12
0
/* NB: doesn't handle binary strings... use prepared stmts for that */
static int sqlite_handle_quoter(pdo_dbh_t *dbh, const char *unquoted, size_t unquotedlen, char **quoted, size_t *quotedlen, enum pdo_param_type paramtype )
{
	*quoted = safe_emalloc(2, unquotedlen, 3);
	sqlite3_snprintf(2*unquotedlen + 3, *quoted, "'%q'", unquoted);
	*quotedlen = strlen(*quoted);
	return 1;
}
Exemplo n.º 13
0
PHPAPI char *php_com_olestring_to_string(OLECHAR *olestring, uint *string_len, int codepage TSRMLS_DC)
{
    char *string;
    uint length = 0;
    BOOL ok;

    length = WideCharToMultiByte(codepage, 0, olestring, -1, NULL, 0, NULL, NULL);

    if (length) {
        string = (char*)safe_emalloc(length, sizeof(char), 0);
        length = WideCharToMultiByte(codepage, 0, olestring, -1, string, length, NULL, NULL);
        ok = length > 0;
    } else {
        string = (char*)emalloc(sizeof(char));
        *string = '\0';
        ok = FALSE;
        length = 0;
    }

    if (!ok) {
        char *msg = php_win32_error_to_msg(GetLastError());

        php_error_docref(NULL TSRMLS_CC, E_WARNING,
                         "Could not convert string from unicode: `%s'", msg);

        LocalFree(msg);
    }

    if (string_len) {
        *string_len = length-1;
    }

    return string;
}
Exemplo n.º 14
0
PHPAPI OLECHAR *php_com_string_to_olestring(char *string, uint string_len, int codepage TSRMLS_DC)
{
    OLECHAR *olestring = NULL;
    DWORD flags = codepage == CP_UTF8 ? 0 : MB_PRECOMPOSED | MB_ERR_INVALID_CHARS;
    BOOL ok;

    if (string_len == -1) {
        /* determine required length for the buffer (includes NUL terminator) */
        string_len = MultiByteToWideChar(codepage, flags, string, -1, NULL, 0);
    } else {
        /* allow room for NUL terminator */
        string_len++;
    }

    if (string_len > 0) {
        olestring = (OLECHAR*)safe_emalloc(string_len, sizeof(OLECHAR), 0);
        ok = MultiByteToWideChar(codepage, flags, string, string_len, olestring, string_len);
    } else {
        ok = FALSE;
        olestring = (OLECHAR*)emalloc(sizeof(OLECHAR));
        *olestring = 0;
    }

    if (!ok) {
        char *msg = php_win32_error_to_msg(GetLastError());

        php_error_docref(NULL TSRMLS_CC, E_WARNING,
                         "Could not convert string to unicode: `%s'", msg);

        LocalFree(msg);
    }

    return olestring;
}
Exemplo n.º 15
0
static int _common_callback_no_arg(void *yajl_ctx, char *type) {
    php_yajl_record *instance = (php_yajl_record *)yajl_ctx;
    zval *return_handle = NULL;
    HashTable *hash;
    zval zType, zArg, *pzType=&zType, *pzArg=&zArg;

    /* Tell PHP where to put the return value */
    php_printf("%p\n", &instance->fci);
    instance->fci.retval_ptr_ptr = &return_handle;

    /* Bundle all the input parameters into an array. */
    instance->fci.params = safe_emalloc(sizeof(zval *), 3, 0);
    instance->fci.param_count = 3;
    instance->fci.params[0] = &instance->php_ctx;
    ZVAL_STRING(pzType, type, 1);
    instance->fci.params[1] = &pzType;
    ZVAL_NULL(pzArg);
    instance->fci.params[2] = &pzArg;

    /* Call the supplied function. */
    zend_call_function(&instance->fci, &instance->fci_cache TSRMLS_CC);

    /* If the allocation succeeded, free the parameter array. */
    if(instance->fci.params) {
        efree(instance->fci.params);
    }

    /* Without this, PHP seems to want to abort trap on me. */
    return 1;
}
Exemplo n.º 16
0
static void
ra_index_change_keys(const char *cmd, zval *z_keys, zval *z_redis) {

    int i, argc;
    zval z_fun, z_ret, *z_args;

    /* alloc */
    argc = 1 + zend_hash_num_elements(Z_ARRVAL_P(z_keys));
    z_args = emalloc(argc * sizeof(zval*));

    /* prepare first parameters */
    ZVAL_STRING(&z_fun, cmd);
    z_args = safe_emalloc(sizeof(zval), argc, 0);
    ZVAL_STRING(&z_args[0], PHPREDIS_INDEX_NAME);

    /* prepare keys */
    for (i = 0; i < argc - 1; ++i) {
        zval *zpp;
        zpp = zend_hash_index_find(Z_ARRVAL_P(z_keys), i);
        ZVAL_COPY(&z_args[i+1], zpp);
    }

    /* run cmd */
    call_user_function(&redis_ce->function_table, z_redis, &z_fun, &z_ret, argc, z_args);

    /* don't dtor z_ret, since we're returning z_redis */
    /* free index name zval */
    for (i = 0; i < argc; i++) {
        zval_ptr_dtor(&z_args[i]);
        efree(&z_args[i]);  /* free index name zval */
    }
    efree(z_args);      /* free container */
}
Exemplo n.º 17
0
static char *urlencode(char const *s, int len, int *new_length)
{
	#define safe_emalloc(nmemb, size, offset)	zmalloc((nmemb) * (size) + (offset))
	static unsigned char hexchars[] = "0123456789ABCDEF";
	register unsigned char c;
	unsigned char *to, *start;
	unsigned char const *from, *end;
	
	from = (unsigned char *)s;
	end = (unsigned char *)s + len;
	start = to = (unsigned char *) safe_emalloc(3, len, 1);

	while (from < end) {
		c = *from++;

		if (c == ' ') {
			*to++ = '+';
#ifndef CHARSET_EBCDIC
		} else if ((c < '0' && c != '-' && c != '.') ||
				   (c < 'A' && c > '9') ||
				   (c > 'Z' && c < 'a' && c != '_') ||
				   (c > 'z')) {
			to[0] = '%';
			to[1] = hexchars[c >> 4];
			to[2] = hexchars[c & 15];
			to += 3;
#else /*CHARSET_EBCDIC*/
		} else if (!isalnum(c) && strchr("_-.", c) == NULL) {
Exemplo n.º 18
0
static int pgsql_handle_quoter(pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, char **quoted, int *quotedlen, enum pdo_param_type paramtype)
{
	unsigned char *escaped;
	pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data;
	size_t tmp_len;

	switch (paramtype) {
		case PDO_PARAM_LOB:
			/* escapedlen returned by PQescapeBytea() accounts for trailing 0 */
			escaped = PQescapeByteaConn(H->server, (unsigned char *)unquoted, (size_t)unquotedlen, &tmp_len);
			*quotedlen = (int)tmp_len + 1;
			*quoted = emalloc(*quotedlen + 1);
			memcpy((*quoted)+1, escaped, *quotedlen-2);
			(*quoted)[0] = '\'';
			(*quoted)[*quotedlen-1] = '\'';
			(*quoted)[*quotedlen] = '\0';
			PQfreemem(escaped);
			break;
		default:
			*quoted = safe_emalloc(2, unquotedlen, 3);
			(*quoted)[0] = '\'';
			*quotedlen = PQescapeStringConn(H->server, *quoted + 1, unquoted, (size_t)unquotedlen, NULL);
			(*quoted)[*quotedlen + 1] = '\'';
			(*quoted)[*quotedlen + 2] = '\0';
			*quotedlen += 2;
	}
	return 1;
}
Exemplo n.º 19
0
int php_com_saproxy_create(zend_object *com_object, zval *proxy_out, zval *index)
{
	php_com_saproxy *proxy, *rel = NULL;

	proxy = ecalloc(1, sizeof(*proxy));
	proxy->dimensions = 1;

	if (com_object->ce == php_com_saproxy_class_entry) {
		rel = (php_com_saproxy*) com_object;
		proxy->obj = rel->obj;
		proxy->dimensions += rel->dimensions;
	} else {
		proxy->obj = (php_com_dotnet_object*) com_object;
	}

	GC_ADDREF(&proxy->obj->zo);
	proxy->indices = safe_emalloc(proxy->dimensions, sizeof(zval *), 0);

	if (rel) {
		clone_indices(proxy, rel, rel->dimensions);
	}

	ZVAL_DUP(&proxy->indices[proxy->dimensions-1], index);

	zend_object_std_init(&proxy->std, php_com_saproxy_class_entry);
	proxy->std.handlers = &php_com_saproxy_handlers;
	ZVAL_OBJ(proxy_out, &proxy->std);

	return 1;
}
Exemplo n.º 20
0
/* {{{ php_url_encode
 */
PHPAPI char *php_url_encode(char const *s, int len, int *new_length)
{
	register unsigned char c;
	unsigned char *to, *start;
	unsigned char const *from, *end;
	
	from = (unsigned char *)s;
	end = (unsigned char *)s + len;
	start = to = (unsigned char *) safe_emalloc(3, len, 1);

	while (from < end) {
		c = *from++;

		if (c == ' ') {
			*to++ = '+';
#ifndef CHARSET_EBCDIC
		} else if ((c < '0' && c != '-' && c != '.') ||
				   (c < 'A' && c > '9') ||
				   (c > 'Z' && c < 'a' && c != '_') ||
				   (c > 'z')) {
			to[0] = '%';
			to[1] = hexchars[c >> 4];
			to[2] = hexchars[c & 15];
			to += 3;
#else /*CHARSET_EBCDIC*/
		} else if (!isalnum(c) && strchr("_-.", c) == NULL) {
Exemplo n.º 21
0
/* {{{ wddx_stack_init
 */
static int wddx_stack_init(wddx_stack *stack)
{
	stack->top = 0;
	stack->elements = (void **) safe_emalloc(sizeof(void **), STACK_BLOCK_SIZE, 0);
	stack->max = STACK_BLOCK_SIZE;
	stack->varname = NULL;
	stack->done = 0;

	return SUCCESS;
}
Exemplo n.º 22
0
// time critical
bool PHPQt::qt_metacall(smokephp_object* o, Smoke::Stack args)
{
    Context::setCallType( Context::SlotCall );
    const QMetaObject* staticMetaObject = o->meta();
    const int _id = args[2].s_int;
    const int offset = staticMetaObject->methodOffset();

    const QByteArray signature( staticMetaObject->method(_id).signature() );
    const QByteArray metaMethodName = signature.left( signature.indexOf("(") );

    //! - if we have a slot overridden in php user space: call it
    //!   @see InvokeSlot
    if( PHPQt::methodExists( o->ce_ptr() , metaMethodName.constData()) ) {
        pDebug( PHPQt::Slot ) << " userspace " << signature << o->ce_ptr()->name;
        const int count = staticMetaObject->method( args[2].s_int ).parameterTypes().count() + 1;
        // zval* zmem = ALLOCA_N(zval, count);
        zval** zmem = (zval**) safe_emalloc( sizeof(zval*), count+1, 0);
        for( int i=0;i<count;i++ )
        {
            ALLOC_INIT_ZVAL( zmem[i] );
        }

        // NOTICE is memory allocation safe here?
        InvokeSlot c( o->smoke(), args, o->zval_ptr(), zmem, _id, staticMetaObject, (void**) args[3].s_voidp, metaMethodName );
        c.next();

        efree(zmem);
        return true;

    } else {
        if ( staticMetaObject->indexOfSlot( signature ) != -1 )
        {
            pDebug( PHPQt::Slot ) << " C++ " << signature;
            // return false means this will be done by smoke
            return false;
        } else {
            // TODO error case for undefined methods, see php_qt proxyMethod
            //			const int i = staticMetaObject->indexOfSignal( signature );
            //			const int offset = staticMetaObject->methodOffset(); // The offset is the summary of all methods in the class's superclasses
            pDebug( PHPQt::Signal ) << signature << staticMetaObject->className() << _id << staticMetaObject->methodOffset();

            /* C++ */	//if( _id < offset ) { qWarning() << "got an id smaller than offset"; }

            /**
            * We go through QMetaObject::activate, because it can either be connected to a C++ Slot or a user space Slot
            * cast to a QObject using smoke cast
            * */
            QObject* ptr = (QObject*) o->smoke()->cast( const_cast<void*>( o->ptr() ), o->classId(), cachedQObjectSmokeId );
            void *_b[] = { 0, ((void**) args[3].s_voidp)[1] };
            QMetaObject::activate( ptr, staticMetaObject, 0, _b );
            return true; // success
        }
    } // else method exist
    return false;
}
Exemplo n.º 23
0
/* {{{ mysql_handle_quoter */
static int mysql_handle_quoter(pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, char **quoted, int *quotedlen, enum pdo_param_type paramtype )
{
	pdo_mysql_db_handle *H = (pdo_mysql_db_handle *)dbh->driver_data;
	PDO_DBG_ENTER("mysql_handle_quoter");
	PDO_DBG_INF_FMT("dbh=%p", dbh);
	PDO_DBG_INF_FMT("unquoted=%.*s", unquotedlen, unquoted);
	*quoted = safe_emalloc(2, unquotedlen, 3);
	*quotedlen = mysql_real_escape_string(H->server, *quoted + 1, unquoted, unquotedlen);
	(*quoted)[0] =(*quoted)[++*quotedlen] = '\'';
	(*quoted)[++*quotedlen] = '\0';
	PDO_DBG_INF_FMT("quoted=%.*s", *quotedlen, *quoted);
	PDO_DBG_RETURN(1);
}
Exemplo n.º 24
0
/* {{{ php_xsl_xslt_string_to_xpathexpr()
   Translates a string to a XPath Expression */
static char *php_xsl_xslt_string_to_xpathexpr(const char *str)
{
	const xmlChar *string = (const xmlChar *)str;

	xmlChar *value;
	int str_len;

	str_len = xmlStrlen(string) + 3;

	if (xmlStrchr(string, '"')) {
		if (xmlStrchr(string, '\'')) {
			php_error_docref(NULL, E_WARNING, "Cannot create XPath expression (string contains both quote and double-quotes)");
			return NULL;
		}
		value = (xmlChar*) safe_emalloc (str_len, sizeof(xmlChar), 0);
		snprintf((char*)value, str_len, "'%s'", string);
	} else {
		value = (xmlChar*) safe_emalloc (str_len, sizeof(xmlChar), 0);
		snprintf((char *)value, str_len, "\"%s\"", string);
	}
	return (char *) value;
}
Exemplo n.º 25
0
/* {{{ reference_levdist
 * reference implementation, only optimized for memory usage, not speed */
static int reference_levdist(const char *s1, int l1, 
														 const char *s2, int l2, 
														 int cost_ins, int cost_rep, int cost_del )
{
	int *p1, *p2, *tmp;
	int i1, i2, c0, c1, c2;
	
	if(l1==0) return l2*cost_ins;
	if(l2==0) return l1*cost_del;

	if((l1>LEVENSHTEIN_MAX_LENTH)||(l2>LEVENSHTEIN_MAX_LENTH))
		return -1;

	p1 = safe_emalloc((l2+1), sizeof(int), 0);
	p2 = safe_emalloc((l2+1), sizeof(int), 0);

	for(i2=0;i2<=l2;i2++)
		p1[i2] = i2*cost_ins;

	for(i1=0;i1<l1;i1++)
		{
			p2[0]=p1[0]+cost_del;
			for(i2=0;i2<l2;i2++)
				{
					c0=p1[i2]+((s1[i1]==s2[i2])?0:cost_rep);
					c1=p1[i2+1]+cost_del; if(c1<c0) c0=c1;
					c2=p2[i2]+cost_ins; if(c2<c0) c0=c2;				
					p2[i2+1]=c0;
				}
			tmp=p1; p1=p2; p2=tmp;
		}

	c0=p1[l2];

	efree(p1);
	efree(p2);

	return c0;
}
Exemplo n.º 26
0
static void
_start_element_handler_ns(void *user, const xmlChar *name, const xmlChar *prefix, const xmlChar *URI, int nb_namespaces, const xmlChar ** namespaces, int nb_attributes, int nb_defaulted, const xmlChar ** attributes)
{
	XML_Parser  parser = (XML_Parser) user;
	xmlChar    *qualified_name = NULL;
	xmlChar **attrs = NULL;
	int i;
	int z = 0;
	int y = 0;
	
	if (nb_namespaces > 0 && parser->h_start_ns != NULL) {
		for (i = 0; i < nb_namespaces; i += 1) {
			parser->h_start_ns(parser->user, (const XML_Char *) namespaces[y], (const XML_Char *) namespaces[y+1]);
			y += 2;
		}
		y = 0;
	}
	
	if (parser->h_start_element == NULL && parser->h_default == NULL) {
		return;
	}
	_qualify_namespace(parser, name, URI, &qualified_name);
	
	if (attributes != NULL) {
		xmlChar    *qualified_name_attr = NULL;
		attrs = safe_emalloc((nb_attributes  * 2) + 1, sizeof(int *), 0);

		for (i = 0; i < nb_attributes; i += 1) {

			if (attributes[y+1] != NULL) {
				_qualify_namespace(parser, attributes[y] , attributes[y + 2], &qualified_name_attr);
			} else {
				qualified_name_attr = xmlStrdup(attributes[y]);
			}
			attrs[z] = qualified_name_attr;
			attrs[z + 1] = xmlStrndup(attributes[y + 3] , (int) (attributes[y + 4] - attributes[y + 3]));
			z += 2;
			y += 5;
		}

		attrs[z] = NULL;
	}
	parser->h_start_element(parser->user, (const XML_Char *) qualified_name, (const XML_Char **) attrs);
	if (attrs) {
		for (i = 0; i < z; i++) {
			xmlFree(attrs[i]);
		}
		efree(attrs);
	}
	xmlFree(qualified_name);
}
Exemplo n.º 27
0
/* bring the palette colors in im2 to be closer to im1
 *
 */
int gdImageColorMatch (gdImagePtr im1, gdImagePtr im2)
{
	unsigned long *buf; /* stores our calculations */
	unsigned long *bp; /* buf ptr */
	int color, rgb;
	int x,y;
	int count;

	if( !im1->trueColor ) {
		return -1; /* im1 must be True Color */
	}
	if( im2->trueColor ) {
		return -2; /* im2 must be indexed */
	}
	if( (im1->sx != im2->sx) || (im1->sy != im2->sy) ) {
		return -3; /* the images are meant to be the same dimensions */
	}
	if (im2->colorsTotal<1) {
		return -4; /* At least 1 color must be allocated */
	}

	buf = (unsigned long *)safe_emalloc(sizeof(unsigned long), 5 * im2->colorsTotal, 0);
	memset( buf, 0, sizeof(unsigned long) * 5 * im2->colorsTotal );

	for (x=0; x<im1->sx; x++) {
		for( y=0; y<im1->sy; y++ ) {
			color = im2->pixels[y][x];
			rgb = im1->tpixels[y][x];
			bp = buf + (color * 5);
			(*(bp++))++;
			*(bp++) += gdTrueColorGetRed(rgb);
			*(bp++) += gdTrueColorGetGreen(rgb);
			*(bp++) += gdTrueColorGetBlue(rgb);
			*(bp++) += gdTrueColorGetAlpha(rgb);
		}
	}
	bp = buf;
	for (color=0; color<im2->colorsTotal; color++) {
		count = *(bp++);
		if( count > 0 ) {
			im2->red[color]		= *(bp++) / count;
			im2->green[color]	= *(bp++) / count;
			im2->blue[color]	= *(bp++) / count;
			im2->alpha[color]	= *(bp++) / count;
		} else {
			bp += 4;
		}
	}
	gdFree(buf);
	return 0;
}
Exemplo n.º 28
0
/* {{{ metaphone
 */
static int metaphone(unsigned char *word, int word_len, long max_phonemes, char **phoned_word, int traditional)
{
	int w_idx = 0;				/* point in the phonization we're at. */
	int p_idx = 0;				/* end of the phoned phrase */
	int max_buffer_len = 0;		/* maximum length of the destination buffer */

/*-- Parameter checks --*/
	/* Negative phoneme length is meaningless */

	if (max_phonemes < 0)
		return -1;

	/* Empty/null string is meaningless */
	/* Overly paranoid */
	/* assert(word != NULL && word[0] != '\0'); */

	if (word == NULL)
		return -1;

/*-- Allocate memory for our phoned_phrase --*/
	if (max_phonemes == 0) {	/* Assume largest possible */
		max_buffer_len = word_len;
		*phoned_word = safe_emalloc(sizeof(char), word_len, 1);
	} else {
		max_buffer_len = max_phonemes;
		*phoned_word = safe_emalloc(sizeof(char), max_phonemes, 1);
	}


/*-- The first phoneme has to be processed specially. --*/
	/* Find our first letter */
	for (; !isalpha(Curr_Letter); w_idx++) {
		/* On the off chance we were given nothing but crap... */
		if (Curr_Letter == '\0') {
			End_Phoned_Word
				return SUCCESS;	/* For testing */
		}
	}
Exemplo n.º 29
0
char *php_geo_geohash_encode(double latitude, double longitude, int precision)
{
	char            *hash;
	int              steps;
	double           coord, mid;
	int              is_even = 1;
	unsigned int     hash_char = 0;
	int              i;
	interval_struct  lat_interval = { MAX_LAT, MIN_LAT };
	interval_struct  lng_interval = { MAX_LONG, MIN_LONG };
	interval_struct *interval;

        if (precision < 0) {
            precision = 0;
        }

	hash = (char*)safe_emalloc(precision, sizeof(char), 1);

	hash[precision] = '\0';
	steps = precision * 5.0;

	for (i = 1; i <= steps; i++) {
		if (is_even) {
			interval = &lng_interval;
			coord = longitude;
		} else {
			interval = &lat_interval;
			coord = latitude;
		}

		mid = (interval->low + interval->high) / 2.0;
		hash_char = hash_char << 1;

		if (coord > mid) {
			interval->low = mid;
			hash_char |= 0x01;
		} else {
			interval->high = mid;
		}

		if (!(i % 5)) {
			hash[(i - 1) / 5] = char_map[hash_char];
			hash_char = 0;
		}

		is_even = !is_even;
	}

	return hash;
}
Exemplo n.º 30
0
char *php_addslashes(char *str, int length, int *new_length)
{
    /* maximum string length, worst case situation */
    char *new_str;
    char *source, *target;
    char *end;
    int local_new_length;

    if (!new_length) 
    {
        new_length = &local_new_length;
    }
    if (!str) 
    {
        *new_length = 0;
        return str;
    }

    new_str = (char *) safe_emalloc(2, (length ? length : (length = strlen(str))), 1);
    source  = str;
    end     = source + length;
    target  = new_str;

    while (source < end) 
    {
        switch (*source) 
        {
            case '\0':
                *target++ = '\\';
                *target++ = '0';
                break;
            case '\'':
            case '\"':
            case '\\':
                *target++ = '\\';
                /* break is missing *intentionally* */
            default:
                *target++ = *source;
                break;
        }

        source++;
    }

    *target     = 0;
    *new_length = target - new_str;

    new_str = (char *) realloc(new_str, *new_length + 1);
    return new_str;
}