static union _zend_function *com_method_get(zend_object **object_ptr, zend_string *name, const zval *key) { zend_internal_function f, *fptr = NULL; union _zend_function *func; DISPID dummy; php_com_dotnet_object *obj = (php_com_dotnet_object*)*object_ptr; if (V_VT(&obj->v) != VT_DISPATCH) { return NULL; } if (FAILED(php_com_get_id_of_name(obj, name->val, name->len, &dummy))) { return NULL; } /* check cache */ if (obj->method_cache == NULL || NULL == (fptr = zend_hash_find_ptr(obj->method_cache, name))) { f.type = ZEND_OVERLOADED_FUNCTION; f.num_args = 0; f.arg_info = NULL; f.scope = obj->ce; f.fn_flags = ZEND_ACC_CALL_VIA_HANDLER; f.function_name = zend_string_copy(name); f.handler = PHP_FN(com_method_handler); fptr = &f; if (obj->typeinfo) { /* look for byref params */ ITypeComp *comp; ITypeInfo *TI = NULL; DESCKIND kind; BINDPTR bindptr; OLECHAR *olename; ULONG lhash; int i; if (SUCCEEDED(ITypeInfo_GetTypeComp(obj->typeinfo, &comp))) { olename = php_com_string_to_olestring(name->val, name->len, obj->code_page); lhash = LHashValOfNameSys(SYS_WIN32, LOCALE_SYSTEM_DEFAULT, olename); if (SUCCEEDED(ITypeComp_Bind(comp, olename, lhash, INVOKE_FUNC, &TI, &kind, &bindptr))) { switch (kind) { case DESCKIND_FUNCDESC: f.arg_info = ecalloc(bindptr.lpfuncdesc->cParams, sizeof(zend_arg_info)); for (i = 0; i < bindptr.lpfuncdesc->cParams; i++) { f.arg_info[i].allow_null = 1; if (bindptr.lpfuncdesc->lprgelemdescParam[i].paramdesc.wParamFlags & PARAMFLAG_FOUT) { f.arg_info[i].pass_by_reference = ZEND_SEND_BY_REF; } } f.num_args = bindptr.lpfuncdesc->cParams; ITypeInfo_ReleaseFuncDesc(TI, bindptr.lpfuncdesc); break; /* these should not happen, but *might* happen if the user * screws up; lets avoid a leak in that case */ case DESCKIND_VARDESC: ITypeInfo_ReleaseVarDesc(TI, bindptr.lpvardesc); break; case DESCKIND_TYPECOMP: ITypeComp_Release(bindptr.lptcomp); break; case DESCKIND_NONE: break; } if (TI) { ITypeInfo_Release(TI); } } ITypeComp_Release(comp); efree(olename); } } zend_set_function_arg_flags((zend_function*)&f); /* save this method in the cache */ if (!obj->method_cache) { ALLOC_HASHTABLE(obj->method_cache); zend_hash_init(obj->method_cache, 2, NULL, function_dtor, 0); } zend_hash_update_mem(obj->method_cache, name, &f, sizeof(f)); } if (fptr) { /* duplicate this into a new chunk of emalloc'd memory, * since the engine will efree it */ func = emalloc(sizeof(*fptr)); memcpy(func, fptr, sizeof(*fptr)); return func; } return NULL; }
PHP_REDIS_API redis_pool* redis_pool_new(TSRMLS_D) { return ecalloc(1, sizeof(redis_pool)); }
static zend_object *spl_heap_object_new_ex(zend_class_entry *class_type, zval *orig, int clone_orig) /* {{{ */ { spl_heap_object *intern; zend_class_entry *parent = class_type; int inherited = 0; intern = ecalloc(1, sizeof(spl_heap_object) + zend_object_properties_size(parent)); zend_object_std_init(&intern->std, class_type); object_properties_init(&intern->std, class_type); intern->flags = 0; intern->fptr_cmp = NULL; if (orig) { spl_heap_object *other = Z_SPLHEAP_P(orig); intern->ce_get_iterator = other->ce_get_iterator; if (clone_orig) { int i; intern->heap = spl_ptr_heap_clone(other->heap); for (i = 0; i < intern->heap->count; ++i) { if (Z_REFCOUNTED(intern->heap->elements[i])) { Z_ADDREF(intern->heap->elements[i]); } } } else { intern->heap = other->heap; } intern->flags = other->flags; } else { intern->heap = spl_ptr_heap_init(spl_ptr_heap_zval_max_cmp, spl_ptr_heap_zval_ctor, spl_ptr_heap_zval_dtor); } intern->std.handlers = &spl_handler_SplHeap; while (parent) { if (parent == spl_ce_SplPriorityQueue) { intern->heap->cmp = spl_ptr_pqueue_zval_cmp; intern->flags = SPL_PQUEUE_EXTR_DATA; intern->std.handlers = &spl_handler_SplPriorityQueue; break; } if (parent == spl_ce_SplMinHeap) { intern->heap->cmp = spl_ptr_heap_zval_min_cmp; break; } if (parent == spl_ce_SplMaxHeap) { intern->heap->cmp = spl_ptr_heap_zval_max_cmp; break; } if (parent == spl_ce_SplHeap) { break; } parent = parent->parent; inherited = 1; } if (!parent) { /* this must never happen */ php_error_docref(NULL, E_COMPILE_ERROR, "Internal compiler error, Class is not child of SplHeap"); } if (inherited) { intern->fptr_cmp = zend_hash_str_find_ptr(&class_type->function_table, "compare", sizeof("compare") - 1); if (intern->fptr_cmp->common.scope == parent) { intern->fptr_cmp = NULL; } intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1); if (intern->fptr_count->common.scope == parent) { intern->fptr_count = NULL; } } return &intern->std; }
PHP_COUCHBASE_LOCAL lcb_error_t simple_observe(lcb_t instance, struct observe_entry *entries, int nentries, long persist_to, long replicate_to) { lcb_error_t err = LCB_SUCCESS; lcb_observe_cmd_t *cmds = ecalloc(nentries, sizeof(lcb_observe_cmd_t)); lcb_observe_cmd_t **commands = ecalloc(nentries, sizeof(lcb_observe_cmd_t *)); int ii; lcb_observe_callback org = lcb_set_observe_callback(instance, simple_observe_callback); struct observe_cookie cookie; int xx; int done = 0; int numtries = 0; int interval = INI_INT(PCBC_INIENT_OBS_INTERVAL); int maxretry = INI_INT(PCBC_INIENT_OBS_TIMEOUT) / interval; cookie.entries = entries; cookie.num = nentries; cookie.error = LCB_SUCCESS; lcb_behavior_set_syncmode(instance, LCB_SYNCHRONOUS); do { /* set up the commands */ for (xx = 0, ii = 0; ii < nentries; ++ii) { cmds[ii].v.v0.key = entries[ii].key; cmds[ii].v.v0.nkey = entries[ii].nkey; if (should_add(&entries[ii], persist_to, replicate_to)) { commands[xx++] = cmds + ii; } } if (xx > 0) { if (numtries > 0) { usleep(interval); } ++numtries; err = lcb_observe(instance, &cookie, xx, (const lcb_observe_cmd_t * const *)commands); } else { done = 1; } } while (!done && numtries < maxretry); efree(cmds); efree(commands); lcb_behavior_set_syncmode(instance, LCB_ASYNCHRONOUS); lcb_set_observe_callback(instance, org); if (!done) { return LCB_ETIMEDOUT; } return (err == LCB_SUCCESS) ? cookie.error : err; }
static int odbc_stmt_execute(pdo_stmt_t *stmt) { RETCODE rc; pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data; char *buf = NULL; SQLLEN row_count = -1; if (stmt->executed) { SQLCloseCursor(S->stmt); } rc = SQLExecute(S->stmt); while (rc == SQL_NEED_DATA) { struct pdo_bound_param_data *param; rc = SQLParamData(S->stmt, (SQLPOINTER*)¶m); if (rc == SQL_NEED_DATA) { php_stream *stm; int len; pdo_odbc_param *P; zval *parameter; P = (pdo_odbc_param*)param->driver_data; if (Z_ISREF(param->parameter)) { parameter = Z_REFVAL(param->parameter); } else { parameter = ¶m->parameter; } if (Z_TYPE_P(parameter) != IS_RESOURCE) { /* they passed in a string */ zend_ulong ulen; convert_to_string(parameter); switch (pdo_odbc_utf82ucs2(stmt, P->is_unicode, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), &ulen)) { case PDO_ODBC_CONV_NOT_REQUIRED: SQLPutData(S->stmt, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter)); break; case PDO_ODBC_CONV_OK: SQLPutData(S->stmt, S->convbuf, ulen); break; case PDO_ODBC_CONV_FAIL: pdo_odbc_stmt_error("error converting input string"); SQLCloseCursor(S->stmt); if (buf) { efree(buf); } return 0; } continue; } /* we assume that LOBs are binary and don't need charset * conversion */ php_stream_from_zval_no_verify(stm, parameter); if (!stm) { /* shouldn't happen either */ pdo_odbc_stmt_error("input LOB is no longer a stream"); SQLCloseCursor(S->stmt); if (buf) { efree(buf); } return 0; } /* now suck data from the stream and stick it into the database */ if (buf == NULL) { buf = emalloc(8192); } do { len = php_stream_read(stm, buf, 8192); if (len == 0) { break; } SQLPutData(S->stmt, buf, len); } while (1); } } if (buf) { efree(buf); } switch (rc) { case SQL_SUCCESS: break; case SQL_NO_DATA_FOUND: case SQL_SUCCESS_WITH_INFO: pdo_odbc_stmt_error("SQLExecute"); break; default: pdo_odbc_stmt_error("SQLExecute"); return 0; } SQLRowCount(S->stmt, &row_count); stmt->row_count = row_count; if (!stmt->executed) { /* do first-time-only definition of bind/mapping stuff */ SQLSMALLINT colcount; /* how many columns do we have ? */ SQLNumResultCols(S->stmt, &colcount); stmt->column_count = (int)colcount; S->cols = ecalloc(colcount, sizeof(pdo_odbc_column)); S->going_long = 0; } return 1; }
void zend_update_property_double(zend_class_entry *scope, zval *object, char *name, int name_length, double value TSRMLS_DC) { zval *tmp = ecalloc(1, sizeof(zval)); ZVAL_DOUBLE(tmp, value); zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC); }
void zend_update_property_bool(zend_class_entry *scope, zval *object, char *name, int name_length, long value TSRMLS_DC) { zval *tmp = ecalloc(1, sizeof(zval)); ZVAL_BOOL(tmp, value); zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC); }
/** * Populate an observe collection with the appropriate key contexts * @param res the couchbase object * @param ocoll an already allocated collection object * @param akc a zend array mapping keys to their expected CAS values * @param expectation an array of durability requirements * @param append_prefix - whether the keys should be appended with the * couchbase-level prefix */ static int oks_build_context(php_couchbase_res *res, struct observe_collection *ocoll, struct observe_expectation *expectation, zval *akc, int append_prefix) { int nks, ix; struct observe_keystate *ks; nks = pcbc_ht_len(akc); ks = ecalloc(sizeof(*ks), nks); for (ix = 0, pcbc_ht_iter_init(akc); pcbc_ht_iter_remaining(akc); pcbc_ht_iter_next(akc), ix++) { pcbc_ht_entry *kv = pcbc_ht_iter_entry(akc); struct observe_keystate *oks = ks + ix; if (kv->key_info->key_len == 0) { ix--; continue; } oks->parent = ocoll; if (expectation) { oks->expected = *expectation; } if ((oks->expected.cas = cas_from_zval(kv->data)) == -1) { pcbc_ht_entry_free(kv); goto GT_CLEANUP; } if (append_prefix && res->prefix_key_len && ocoll->prefix_appended == 0) { pcbc_ht_key prefixed_ki; make_prefixed_hk(res, kv->key_info->key, kv->key_info->key_len, &prefixed_ki); oks->ocmd.v.v0.nkey = prefixed_ki.key_len; oks->ocmd.v.v0.key = emalloc(prefixed_ki.key_len); memcpy((char *)oks->ocmd.v.v0.key, prefixed_ki.key, prefixed_ki.key_len); pcbc_ht_key_cleanup(&prefixed_ki); } else { oks->ocmd.v.v0.key = emalloc(kv->key_info->key_len); oks->ocmd.v.v0.nkey = kv->key_info->key_len; memcpy((char *)oks->ocmd.v.v0.key, kv->key_info->key, oks->ocmd.v.v0.nkey); } pcbc_ht_entry_free(kv); if (append_prefix && res->prefix_key_len) { ocoll->prefix_appended = 1; } } ocoll->ks = ks; ocoll->nks = ix; ocoll->remaining = ocoll->nks; ocoll->res = res; return 0; GT_CLEANUP: for (ix = 0; ix < nks; ix++) { struct observe_keystate *oks = ks + ix; if (oks->ocmd.v.v0.key) { efree((void *) oks->ocmd.v.v0.key); } } efree(ks); return -1; }
static zend_object *spl_fixedarray_object_new_ex(zend_class_entry *class_type, zval *orig, int clone_orig) /* {{{ */ { spl_fixedarray_object *intern; zend_class_entry *parent = class_type; int inherited = 0; intern = ecalloc(1, sizeof(spl_fixedarray_object) + zend_object_properties_size(parent)); zend_object_std_init(&intern->std, class_type); object_properties_init(&intern->std, class_type); intern->current = 0; intern->flags = 0; if (orig && clone_orig) { spl_fixedarray_object *other = Z_SPLFIXEDARRAY_P(orig); intern->ce_get_iterator = other->ce_get_iterator; spl_fixedarray_init(&intern->array, other->array.size); spl_fixedarray_copy(&intern->array, &other->array); } while (parent) { if (parent == spl_ce_SplFixedArray) { intern->std.handlers = &spl_handler_SplFixedArray; class_type->get_iterator = spl_fixedarray_get_iterator; break; } parent = parent->parent; inherited = 1; } if (!parent) { /* this must never happen */ php_error_docref(NULL, E_COMPILE_ERROR, "Internal compiler error, Class is not child of SplFixedArray"); } if (!class_type->iterator_funcs.zf_current) { class_type->iterator_funcs.zf_rewind = zend_hash_str_find_ptr(&class_type->function_table, "rewind", sizeof("rewind") - 1); class_type->iterator_funcs.zf_valid = zend_hash_str_find_ptr(&class_type->function_table, "valid", sizeof("valid") - 1); class_type->iterator_funcs.zf_key = zend_hash_str_find_ptr(&class_type->function_table, "key", sizeof("key") - 1); class_type->iterator_funcs.zf_current = zend_hash_str_find_ptr(&class_type->function_table, "current", sizeof("current") - 1); class_type->iterator_funcs.zf_next = zend_hash_str_find_ptr(&class_type->function_table, "next", sizeof("next") - 1); } if (inherited) { if (class_type->iterator_funcs.zf_rewind->common.scope != parent) { intern->flags |= SPL_FIXEDARRAY_OVERLOADED_REWIND; } if (class_type->iterator_funcs.zf_valid->common.scope != parent) { intern->flags |= SPL_FIXEDARRAY_OVERLOADED_VALID; } if (class_type->iterator_funcs.zf_key->common.scope != parent) { intern->flags |= SPL_FIXEDARRAY_OVERLOADED_KEY; } if (class_type->iterator_funcs.zf_current->common.scope != parent) { intern->flags |= SPL_FIXEDARRAY_OVERLOADED_CURRENT; } if (class_type->iterator_funcs.zf_next->common.scope != parent) { intern->flags |= SPL_FIXEDARRAY_OVERLOADED_NEXT; } intern->fptr_offset_get = zend_hash_str_find_ptr(&class_type->function_table, "offsetget", sizeof("offsetget") - 1); if (intern->fptr_offset_get->common.scope == parent) { intern->fptr_offset_get = NULL; } intern->fptr_offset_set = zend_hash_str_find_ptr(&class_type->function_table, "offsetset", sizeof("offsetset") - 1); if (intern->fptr_offset_set->common.scope == parent) { intern->fptr_offset_set = NULL; } intern->fptr_offset_has = zend_hash_str_find_ptr(&class_type->function_table, "offsetexists", sizeof("offsetexists") - 1); if (intern->fptr_offset_has->common.scope == parent) { intern->fptr_offset_has = NULL; } intern->fptr_offset_del = zend_hash_str_find_ptr(&class_type->function_table, "offsetunset", sizeof("offsetunset") - 1); if (intern->fptr_offset_del->common.scope == parent) { intern->fptr_offset_del = NULL; } intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1); if (intern->fptr_count->common.scope == parent) { intern->fptr_count = NULL; } } return &intern->std; }
/* {{{ apc_iterator_item */ static apc_iterator_item_t* apc_iterator_item_ctor(apc_iterator_t *iterator, slot_t **slot_pp) { zval *zvalue; char md5str[33]; slot_t *slot = *slot_pp; apc_context_t ctxt = {0, }; apc_iterator_item_t *item = ecalloc(1, sizeof(apc_iterator_item_t)); if (slot->key.type == APC_CACHE_KEY_FILE) { /* keys should be unique and with stat=1 we could have multiple files with the same name, so use '<device> <inode>' instead */ #ifdef PHP_WIN32 item->key_len = spprintf(&item->key, 0, "%I64d %I64d", slot->key.data.file.device, slot->key.data.file.inode); #else item->key_len = spprintf(&item->key, 0, "%ld %ld", (ulong)slot->key.data.file.device, (ulong)slot->key.data.file.inode); #endif item->filename_key = estrdup(slot->value->data.file.filename); } else if (slot->key.type == APC_CACHE_KEY_USER) { item->key = estrndup((char*)slot->key.data.user.identifier, slot->key.data.user.identifier_len); item->key_len = slot->key.data.user.identifier_len; item->filename_key = item->key; } else if (slot->key.type == APC_CACHE_KEY_FPFILE) { item->key = estrndup((char*)slot->key.data.fpfile.fullpath, slot->key.data.fpfile.fullpath_len); item->key_len = slot->key.data.fpfile.fullpath_len; } else { apc_eprint("Internal error, invalid entry type."); } ALLOC_INIT_ZVAL(item->value); array_init(item->value); if (APC_ITER_TYPE & iterator->format) { if(slot->value->type == APC_CACHE_ENTRY_FILE) { add_assoc_string(item->value, "type", "file", 1); } else if(slot->value->type == APC_CACHE_ENTRY_USER) { add_assoc_string(item->value, "type", "user", 1); } } if (APC_ITER_FILENAME & iterator->format) { if(slot->value->type == APC_CACHE_ENTRY_FILE) { if (slot->key.type == APC_CACHE_KEY_FILE) { add_assoc_string(item->value, "filename", slot->value->data.file.filename, 1); } else { /* APC_CACHE_FPFILE */ add_assoc_string(item->value, "filename", (char*)slot->key.data.fpfile.fullpath, 1); } } } if (APC_ITER_DEVICE & iterator->format) { if(slot->key.type == APC_CACHE_KEY_FILE) { #ifdef PHP_WIN32 char buf[20]; sprintf(buf, "%I64d", slot->key.data.file.device); add_assoc_string(item->value, "device", buf, 1); #else add_assoc_long(item->value, "device", slot->key.data.file.device); #endif } } if (APC_ITER_INODE & iterator->format) { if(slot->key.type == APC_CACHE_KEY_FILE) { #ifdef PHP_WIN32 char buf[20]; sprintf(buf, "%I64d", slot->key.data.file.device); add_assoc_string(item->value, "device", buf, 1); #else add_assoc_long(item->value, "inode", slot->key.data.file.inode); #endif } } if (APC_ITER_KEY & iterator->format) { add_assoc_stringl(item->value, "key", item->key, item->key_len, 1); } if (APC_ITER_VALUE & iterator->format) { if(slot->value->type == APC_CACHE_ENTRY_USER) { ctxt.pool = apc_pool_create(APC_UNPOOL, apc_php_malloc, apc_php_free, NULL, NULL); ctxt.copy = APC_COPY_OUT_USER; MAKE_STD_ZVAL(zvalue); apc_cache_fetch_zval(zvalue, slot->value->data.user.val, &ctxt); apc_pool_destroy(ctxt.pool); add_assoc_zval(item->value, "value", zvalue); } } if (APC_ITER_MD5 & iterator->format) { if(slot->value->type == APC_CACHE_ENTRY_FILE) { if(slot->key.md5) { make_digest(md5str, slot->key.md5); add_assoc_string(item->value, "md5", md5str, 1); } } } if (APC_ITER_NUM_HITS & iterator->format) { add_assoc_long(item->value, "num_hits", slot->num_hits); } if (APC_ITER_MTIME & iterator->format) { add_assoc_long(item->value, "mtime", slot->key.mtime); } if (APC_ITER_CTIME & iterator->format) { add_assoc_long(item->value, "creation_time", slot->creation_time); } if (APC_ITER_DTIME & iterator->format) { add_assoc_long(item->value, "deletion_time", slot->deletion_time); } if (APC_ITER_ATIME & iterator->format) { add_assoc_long(item->value, "access_time", slot->access_time); } if (APC_ITER_REFCOUNT & iterator->format) { add_assoc_long(item->value, "ref_count", slot->value->ref_count); } if (APC_ITER_MEM_SIZE & iterator->format) { add_assoc_long(item->value, "mem_size", slot->value->mem_size); } if (APC_ITER_TTL & iterator->format) { if(slot->value->type == APC_CACHE_ENTRY_USER) { add_assoc_long(item->value, "ttl", slot->value->data.user.ttl); } } return item; }
static int oci_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, enum pdo_param_event event_type) /* {{{ */ { pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data; /* we're only interested in parameters for prepared SQL right now */ if (param->is_param) { pdo_oci_bound_param *P; sb4 value_sz = -1; P = (pdo_oci_bound_param*)param->driver_data; switch (event_type) { case PDO_PARAM_EVT_FETCH_PRE: case PDO_PARAM_EVT_FETCH_POST: case PDO_PARAM_EVT_NORMALIZE: /* Do nothing */ break; case PDO_PARAM_EVT_FREE: P = param->driver_data; if (P) { efree(P); } break; case PDO_PARAM_EVT_ALLOC: P = (pdo_oci_bound_param*)ecalloc(1, sizeof(pdo_oci_bound_param)); param->driver_data = P; /* figure out what we're doing */ switch (PDO_PARAM_TYPE(param->param_type)) { case PDO_PARAM_STMT: return 0; case PDO_PARAM_LOB: /* P->thing is now an OCILobLocator * */ P->oci_type = SQLT_BLOB; value_sz = sizeof(OCILobLocator*); break; case PDO_PARAM_STR: default: P->oci_type = SQLT_CHR; value_sz = param->max_value_len; if (param->max_value_len == 0) { value_sz = 1332; /* maximum size before value is interpreted as a LONG value */ } } if (param->name) { STMT_CALL(OCIBindByName, (S->stmt, &P->bind, S->err, (text*)param->name, param->namelen, 0, value_sz, P->oci_type, &P->indicator, 0, &P->retcode, 0, 0, OCI_DATA_AT_EXEC)); } else { STMT_CALL(OCIBindByPos, (S->stmt, &P->bind, S->err, param->paramno+1, 0, value_sz, P->oci_type, &P->indicator, 0, &P->retcode, 0, 0, OCI_DATA_AT_EXEC)); } STMT_CALL(OCIBindDynamic, (P->bind, S->err, param, oci_bind_input_cb, param, oci_bind_output_cb)); return 1; case PDO_PARAM_EVT_EXEC_PRE: P->indicator = 0; P->used_for_output = 0; if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) { ub4 empty = 0; STMT_CALL(OCIDescriptorAlloc, (S->H->env, &P->thing, OCI_DTYPE_LOB, 0, NULL)); STMT_CALL(OCIAttrSet, (P->thing, OCI_DTYPE_LOB, &empty, 0, OCI_ATTR_LOBEMPTY, S->err)); S->have_blobs = 1; } return 1; case PDO_PARAM_EVT_EXEC_POST: /* fixup stuff set in motion in oci_bind_output_cb */ if (P->used_for_output) { if (P->indicator == -1) { /* set up a NULL value */ if (Z_TYPE_P(param->parameter) == IS_STRING #if ZEND_EXTENSION_API_NO < 220040718 && Z_STRVAL_P(param->parameter) != empty_string #endif ) { /* OCI likes to stick non-terminated strings in things */ *Z_STRVAL_P(param->parameter) = '\0'; } zval_dtor(param->parameter); ZVAL_NULL(param->parameter); } else if (Z_TYPE_P(param->parameter) == IS_STRING #if ZEND_EXTENSION_API_NO < 220040718 && Z_STRVAL_P(param->parameter) != empty_string #endif ) { Z_STRLEN_P(param->parameter) = P->actual_len; Z_STRVAL_P(param->parameter) = erealloc(Z_STRVAL_P(param->parameter), P->actual_len+1); Z_STRVAL_P(param->parameter)[P->actual_len] = '\0'; } } else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB && P->thing) { php_stream *stm; if (Z_TYPE_P(param->parameter) == IS_NULL) { /* if the param is NULL, then we assume that they * wanted to bind a lob locator into it from the query * */ stm = oci_create_lob_stream(stmt, (OCILobLocator*)P->thing); if (stm) { OCILobOpen(S->H->svc, S->err, (OCILobLocator*)P->thing, OCI_LOB_READWRITE); php_stream_to_zval(stm, param->parameter); P->thing = NULL; } } else { /* we're a LOB being used for insert; transfer the data now */ size_t n; ub4 amt, offset = 1; char *consume; php_stream_from_zval_no_verify(stm, ¶m->parameter); if (stm) { OCILobOpen(S->H->svc, S->err, (OCILobLocator*)P->thing, OCI_LOB_READWRITE); do { char buf[8192]; n = php_stream_read(stm, buf, sizeof(buf)); if ((int)n <= 0) { break; } consume = buf; do { amt = n; OCILobWrite(S->H->svc, S->err, (OCILobLocator*)P->thing, &amt, offset, consume, n, OCI_ONE_PIECE, NULL, NULL, 0, SQLCS_IMPLICIT); offset += amt; n -= amt; consume += amt; } while (n); } while (1); OCILobClose(S->H->svc, S->err, (OCILobLocator*)P->thing); OCILobFlushBuffer(S->H->svc, S->err, (OCILobLocator*)P->thing, 0); } else if (Z_TYPE_P(param->parameter) == IS_STRING) { /* stick the string into the LOB */ consume = Z_STRVAL_P(param->parameter); n = Z_STRLEN_P(param->parameter); if (n) { OCILobOpen(S->H->svc, S->err, (OCILobLocator*)P->thing, OCI_LOB_READWRITE); while (n) { amt = n; OCILobWrite(S->H->svc, S->err, (OCILobLocator*)P->thing, &amt, offset, consume, n, OCI_ONE_PIECE, NULL, NULL, 0, SQLCS_IMPLICIT); consume += amt; n -= amt; } OCILobClose(S->H->svc, S->err, (OCILobLocator*)P->thing); } } OCIDescriptorFree(P->thing, OCI_DTYPE_LOB); P->thing = NULL; } } return 1; } } return 1; } /* }}} */
static int oci_stmt_execute(pdo_stmt_t *stmt) /* {{{ */ { pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data; ub4 rowcount; b4 mode; if (!S->stmt_type) { STMT_CALL_MSG(OCIAttrGet, "OCI_ATTR_STMT_TYPE", (S->stmt, OCI_HTYPE_STMT, &S->stmt_type, 0, OCI_ATTR_STMT_TYPE, S->err)); } if (stmt->executed) { /* ensure that we cancel the cursor from a previous fetch */ OCIStmtFetch(S->stmt, S->err, 0, OCI_FETCH_NEXT, OCI_DEFAULT); } #ifdef OCI_STMT_SCROLLABLE_READONLY /* needed for oci8 ? */ if (S->exec_type == OCI_STMT_SCROLLABLE_READONLY) { mode = OCI_STMT_SCROLLABLE_READONLY; } else #endif if (stmt->dbh->auto_commit && !stmt->dbh->in_txn) { mode = OCI_COMMIT_ON_SUCCESS; } else { mode = OCI_DEFAULT; } STMT_CALL(OCIStmtExecute, (S->H->svc, S->stmt, S->err, (S->stmt_type == OCI_STMT_SELECT && !S->have_blobs) ? 0 : 1, 0, NULL, NULL, mode)); if (!stmt->executed) { ub4 colcount; /* do first-time-only definition of bind/mapping stuff */ /* how many columns do we have ? */ STMT_CALL_MSG(OCIAttrGet, "ATTR_PARAM_COUNT", (S->stmt, OCI_HTYPE_STMT, &colcount, 0, OCI_ATTR_PARAM_COUNT, S->err)); stmt->column_count = (int)colcount; if (S->cols) { int i; for (i = 0; i < stmt->column_count; i++) { if (S->cols[i].data) { switch (S->cols[i].dtype) { case SQLT_BLOB: case SQLT_CLOB: /* do nothing */ break; default: efree(S->cols[i].data); } } } efree(S->cols); } S->cols = ecalloc(colcount, sizeof(pdo_oci_column)); } STMT_CALL_MSG(OCIAttrGet, "ATTR_ROW_COUNT", (S->stmt, OCI_HTYPE_STMT, &rowcount, 0, OCI_ATTR_ROW_COUNT, S->err)); stmt->row_count = (long)rowcount; return 1; } /* }}} */
/* {{{ mbfl_no_encoding _php_mb_encoding_handler_ex() */ const mbfl_encoding *_php_mb_encoding_handler_ex(const php_mb_encoding_handler_info_t *info, zval *arg, char *res) { char *var, *val; const char *s1, *s2; char *strtok_buf = NULL, **val_list = NULL; zval *array_ptr = (zval *) arg; int n, num, *len_list = NULL; size_t val_len, new_val_len; mbfl_string string, resvar, resval; const mbfl_encoding *from_encoding = NULL; mbfl_encoding_detector *identd = NULL; mbfl_buffer_converter *convd = NULL; mbfl_string_init_set(&string, info->to_language, info->to_encoding->no_encoding); mbfl_string_init_set(&resvar, info->to_language, info->to_encoding->no_encoding); mbfl_string_init_set(&resval, info->to_language, info->to_encoding->no_encoding); if (!res || *res == '\0') { goto out; } /* count the variables(separators) contained in the "res". * separator may contain multiple separator chars. */ num = 1; for (s1=res; *s1 != '\0'; s1++) { for (s2=info->separator; *s2 != '\0'; s2++) { if (*s1 == *s2) { num++; } } } num *= 2; /* need space for variable name and value */ val_list = (char **)ecalloc(num, sizeof(char *)); len_list = (int *)ecalloc(num, sizeof(int)); /* split and decode the query */ n = 0; strtok_buf = NULL; var = php_strtok_r(res, info->separator, &strtok_buf); while (var) { val = strchr(var, '='); if (val) { /* have a value */ len_list[n] = php_url_decode(var, val-var); val_list[n] = var; n++; *val++ = '\0'; val_list[n] = val; len_list[n] = php_url_decode(val, strlen(val)); } else { len_list[n] = php_url_decode(var, strlen(var)); val_list[n] = var; n++; val_list[n] = ""; len_list[n] = 0; } n++; var = php_strtok_r(NULL, info->separator, &strtok_buf); } if (n > (PG(max_input_vars) * 2)) { php_error_docref(NULL, E_WARNING, "Input variables exceeded %pd. To increase the limit change max_input_vars in php.ini.", PG(max_input_vars)); goto out; } num = n; /* make sure to process initialized vars only */ /* initialize converter */ if (info->num_from_encodings <= 0) { from_encoding = &mbfl_encoding_pass; } else if (info->num_from_encodings == 1) { from_encoding = info->from_encodings[0]; } else { /* auto detect */ from_encoding = NULL; identd = mbfl_encoding_detector_new2(info->from_encodings, info->num_from_encodings, MBSTRG(strict_detection)); if (identd != NULL) { n = 0; while (n < num) { string.val = (unsigned char *)val_list[n]; string.len = len_list[n]; if (mbfl_encoding_detector_feed(identd, &string)) { break; } n++; } from_encoding = mbfl_encoding_detector_judge2(identd); mbfl_encoding_detector_delete(identd); } if (!from_encoding) { if (info->report_errors) { php_error_docref(NULL, E_WARNING, "Unable to detect encoding"); } from_encoding = &mbfl_encoding_pass; } } convd = NULL; if (from_encoding != &mbfl_encoding_pass) { convd = mbfl_buffer_converter_new2(from_encoding, info->to_encoding, 0); if (convd != NULL) { mbfl_buffer_converter_illegal_mode(convd, MBSTRG(current_filter_illegal_mode)); mbfl_buffer_converter_illegal_substchar(convd, MBSTRG(current_filter_illegal_substchar)); } else { if (info->report_errors) { php_error_docref(NULL, E_WARNING, "Unable to create converter"); } goto out; } } /* convert encoding */ string.no_encoding = from_encoding->no_encoding; n = 0; while (n < num) { string.val = (unsigned char *)val_list[n]; string.len = len_list[n]; if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resvar) != NULL) { var = (char *)resvar.val; } else { var = val_list[n]; } n++; string.val = (unsigned char *)val_list[n]; string.len = len_list[n]; if (convd != NULL && mbfl_buffer_converter_feed_result(convd, &string, &resval) != NULL) { val = (char *)resval.val; val_len = resval.len; } else { val = val_list[n]; val_len = len_list[n]; } n++; /* we need val to be emalloc()ed */ val = estrndup(val, val_len); if (sapi_module.input_filter(info->data_type, var, &val, val_len, &new_val_len)) { /* add variable to symbol table */ php_register_variable_safe(var, val, new_val_len, array_ptr); } efree(val); if (convd != NULL) { mbfl_string_clear(&resvar); mbfl_string_clear(&resval); } } out: if (convd != NULL) { MBSTRG(illegalchars) += mbfl_buffer_illegalchars(convd); mbfl_buffer_converter_delete(convd); } if (val_list != NULL) { efree((void *)val_list); } if (len_list != NULL) { efree((void *)len_list); } return from_encoding; }
PHP_COUCHBASE_LOCAL void php_couchbase_get_impl(INTERNAL_FUNCTION_PARAMETERS, int multi, int oo, int lock, int touch) { char *key, **keys; long *klens, klen = 0; int nkey = 0; long flag = 0; lcb_time_t exp = {0}; long expiry = 0; zval *res, *cas_token = NULL; int argflags; lcb_error_t retval; php_couchbase_res *couchbase_res; php_couchbase_ctx *ctx; argflags = oo ? PHP_COUCHBASE_ARG_F_OO : PHP_COUCHBASE_ARG_F_FUNCTIONAL; if (multi) { zval *akeys; zval **ppzval; zend_bool preserve_order; int i; if (lock) { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "az|ll", &akeys, &cas_token, &flag, &expiry); } else if (touch) { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "al|z", &akeys, &expiry, &cas_token); } else { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "a|zl", &akeys, &cas_token, &flag); } nkey = zend_hash_num_elements(Z_ARRVAL_P(akeys)); keys = ecalloc(nkey, sizeof(char *)); klens = ecalloc(nkey, sizeof(long)); preserve_order = (flag & COUCHBASE_GET_PRESERVE_ORDER); array_init(return_value); for (i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys)), i++) { if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { nkey--; continue; } if (IS_ARRAY != Z_TYPE_PP(ppzval)) { convert_to_string_ex(ppzval); } if (!Z_STRLEN_PP(ppzval)) { nkey--; continue; } if (couchbase_res->prefix_key_len) { klens[i] = spprintf(&(keys[i]), 0, "%s_%s", couchbase_res->prefix_key, Z_STRVAL_PP(ppzval)); } else { keys[i] = Z_STRVAL_PP(ppzval); klens[i] = Z_STRLEN_PP(ppzval); } if (preserve_order) { add_assoc_null_ex(return_value, keys[i], klens[i] + 1); } } if (!nkey) { efree(keys); efree(klens); return; } if (cas_token && IS_ARRAY != Z_TYPE_P(cas_token)) { zval_dtor(cas_token); array_init(cas_token); } } else { if (lock) { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "sz|l", &key, &klen, &cas_token, &expiry); } else if (touch) { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "sl|z", &key, &klen, &expiry, &cas_token); } else { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "s|z", &key, &klen, &cas_token); } if (!klen) { return; } nkey = 1; if (couchbase_res->prefix_key_len) { klen = spprintf(&key, 0, "%s_%s", couchbase_res->prefix_key, key); } keys = &key; klens = &klen; if (cas_token) { zval_dtor(cas_token); ZVAL_NULL(cas_token); } } { lcb_get_cmd_t **commands = ecalloc(nkey, sizeof(lcb_get_cmd_t *)); int ii; if (expiry) { exp = pcbc_check_expiry(expiry); } for (ii = 0; ii < nkey; ++ii) { lcb_get_cmd_t *cmd = ecalloc(1, sizeof(lcb_get_cmd_t)); commands[ii] = cmd; cmd->v.v0.key = keys[ii]; cmd->v.v0.nkey = klens[ii]; cmd->v.v0.lock = (int)lock; cmd->v.v0.exptime = exp; /* NB: this assumes sizeof(lcb_time_t) == sizeof(long) */ } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; ctx->cas = cas_token; retval = lcb_get(couchbase_res->handle, ctx, nkey, (const lcb_get_cmd_t * const *)commands); for (ii = 0; ii < nkey; ++ii) { efree(commands[ii]); } efree(commands); if (LCB_SUCCESS != retval) { if (couchbase_res->prefix_key_len) { int i; for (i = 0; i < nkey; i++) { efree(keys[i]); } } if (multi) { efree(keys); efree(klens); zval_dtor(return_value); } efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo, cb_lcb_exception, "Failed to schedule get request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } couchbase_res->seqno += nkey; pcbc_start_loop(couchbase_res); if (LCB_SUCCESS != ctx->res->rc) { if (LCB_KEY_ENOENT != ctx->res->rc) { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo, cb_lcb_exception, "Failed to get a value from server: %s", lcb_strerror(couchbase_res->handle, ctx->res->rc)); } } efree(ctx); if (couchbase_res->prefix_key_len) { int i; for (i = 0; i < nkey; i++) { efree(keys[i]); } } if (multi) { efree(keys); efree(klens); } } }
int count; redis_pool_member *head; } redis_pool; PHP_REDIS_API redis_pool* redis_pool_new(TSRMLS_D) { return ecalloc(1, sizeof(redis_pool)); } PHP_REDIS_API void redis_pool_add(redis_pool *pool, RedisSock *redis_sock, int weight, int database, char *prefix, char *auth TSRMLS_DC) { redis_pool_member *rpm = ecalloc(1, sizeof(redis_pool_member)); rpm->redis_sock = redis_sock; rpm->weight = weight; rpm->database = database; rpm->prefix = prefix; rpm->prefix_len = (prefix?strlen(prefix):0); rpm->auth = auth; rpm->auth_len = (auth?strlen(auth):0); rpm->next = pool->head; pool->head = rpm; pool->totalWeight += weight; }
static int pgsql_handle_preparer(pdo_dbh_t *dbh, const char *sql, size_t sql_len, pdo_stmt_t *stmt, zval *driver_options) { pdo_pgsql_db_handle *H = (pdo_pgsql_db_handle *)dbh->driver_data; pdo_pgsql_stmt *S = ecalloc(1, sizeof(pdo_pgsql_stmt)); int scrollable; int ret; char *nsql = NULL; size_t nsql_len = 0; int emulate = 0; int execute_only = 0; S->H = H; stmt->driver_data = S; stmt->methods = &pgsql_stmt_methods; scrollable = pdo_attr_lval(driver_options, PDO_ATTR_CURSOR, PDO_CURSOR_FWDONLY) == PDO_CURSOR_SCROLL; if (scrollable) { if (S->cursor_name) { efree(S->cursor_name); } spprintf(&S->cursor_name, 0, "pdo_crsr_%08x", ++H->stmt_counter); emulate = 1; } else if (driver_options) { if (pdo_attr_lval(driver_options, PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT, H->disable_native_prepares) == 1) { php_error_docref(NULL, E_DEPRECATED, "PDO::PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT is deprecated, use PDO::ATTR_EMULATE_PREPARES instead"); emulate = 1; } if (pdo_attr_lval(driver_options, PDO_ATTR_EMULATE_PREPARES, H->emulate_prepares) == 1) { emulate = 1; } if (pdo_attr_lval(driver_options, PDO_PGSQL_ATTR_DISABLE_PREPARES, H->disable_prepares) == 1) { execute_only = 1; } } else { emulate = H->disable_native_prepares || H->emulate_prepares; execute_only = H->disable_prepares; } if (!emulate && PQprotocolVersion(H->server) > 2) { stmt->supports_placeholders = PDO_PLACEHOLDER_NAMED; stmt->named_rewrite_template = "$%d"; ret = pdo_parse_params(stmt, (char*)sql, sql_len, &nsql, &nsql_len); if (ret == 1) { /* query was re-written */ sql = nsql; } else if (ret == -1) { /* couldn't grok it */ strcpy(dbh->error_code, stmt->error_code); return 0; } if (!execute_only) { /* prepared query: set the query name and defer the actual prepare until the first execute call */ spprintf(&S->stmt_name, 0, "pdo_stmt_%08x", ++H->stmt_counter); } if (nsql) { S->query = nsql; } else { S->query = estrdup(sql); } return 1; } stmt->supports_placeholders = PDO_PLACEHOLDER_NONE; return 1; }
PHP_COUCHBASE_LOCAL void php_couchbase_store_multi_impl_oo(INTERNAL_FUNCTION_PARAMETERS) { lcb_error_t retval; php_couchbase_res *couchbase_res; php_couchbase_ctx *ctx; time_t exp = {0}; long expire = 0; zval *akeys; long persist_to = 0; long replicate_to = 0; struct observe_entry *entries; int numkeys; lcb_store_cmd_t *cmds; lcb_store_cmd_t **commands; int ii; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_OO, "a|lll", &akeys, &expire, &persist_to, &replicate_to); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, expire, &exp) == -1) { /* Incorrect expiry time */ return; } if (validate_simple_observe_clause(couchbase_res->handle, persist_to, replicate_to TSRMLS_CC) == -1) { /* Exception already thrown */ return; } numkeys = zend_hash_num_elements(Z_ARRVAL_P(akeys)); if (numkeys == 0) { zend_throw_exception(cb_illegal_key_exception, "No items specified", 0 TSRMLS_CC); return ; } entries = ecalloc(numkeys, sizeof(struct observe_entry)); commands = ecalloc(numkeys, sizeof(lcb_store_cmd_t *)); cmds = ecalloc(numkeys, sizeof(lcb_store_cmd_t)); /* link the command pointers */ for (ii = 0; ii < numkeys; ++ii) { commands[ii] = cmds + ii; } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; array_init(ctx->rv); for (ii = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys)), ++ii) { char *key = NULL; uint klen; size_t payload_len = 0; char *payload; unsigned int flags = 0; zval **ppzval; int allocated_key = 0; switch (zend_hash_get_current_key_type(Z_ARRVAL_P(akeys))) { case HASH_KEY_IS_LONG: { ulong kval; zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, &kval, 0); spprintf(&key, 0, "%llu", kval); allocated_key = 1; } break; case HASH_KEY_IS_STRING: zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, NULL, 0); break; default: { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_illegal_key_exception, "Invalid key specified (not a string)", 0 TSRMLS_CC); return ; } } klen = strlen(key); if (klen == 0) { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_illegal_key_exception, "Invalid key specified (empty string)", 0 TSRMLS_CC); return ; } if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_exception, "Failed to get data for key", 0 TSRMLS_CC); return ; } payload = php_couchbase_zval_to_payload(*ppzval, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { /* Shouldn't we call an exception? */ RETURN_FALSE; } if (couchbase_res->prefix_key_len) { char *new_key; allocated_key = 1; klen = spprintf(&new_key, 0, "%s_%s", couchbase_res->prefix_key, key); key = new_key; } entries[ii].nkey = klen; entries[ii].key = emalloc(klen); memcpy(entries[ii].key, key, klen); cmds[ii].v.v0.operation = LCB_SET; cmds[ii].v.v0.key = entries[ii].key; cmds[ii].v.v0.nkey = klen; cmds[ii].v.v0.bytes = payload; cmds[ii].v.v0.nbytes = payload_len; cmds[ii].v.v0.flags = flags; cmds[ii].v.v0.exptime = exp; if (allocated_key) { efree(key); } } retval = lcb_store(couchbase_res->handle, ctx, numkeys, (const lcb_store_cmd_t * const *)commands); couchbase_res->seqno += numkeys; pcbc_start_loop(couchbase_res); /* * Time to release the payloads... */ for (ii = 0; ii < numkeys; ++ii) { efree((void *)cmds[ii].v.v0.bytes); } efree(cmds); efree(commands); if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); release_entry_array(entries, numkeys); RETURN_FALSE; } /* * The item was stored successfully. Did the user want to wait until * it was persisted/replicated? */ if (persist_to != 0 || replicate_to != 0) { int ii = 0; for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(return_value)); zend_hash_has_more_elements(Z_ARRVAL_P(return_value)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(return_value)), ++ii) { zval **curr_cas; zend_hash_get_current_data(Z_ARRVAL_P(return_value), (void **)&curr_cas); if (Z_STRLEN_PP(curr_cas)) { entries[ii].cas = strtoull(Z_STRVAL_PP(curr_cas), 0, 10); } else { /* @todo what to do here? */ fprintf(stderr, "wtf!\n"); } } retval = simple_observe(couchbase_res->handle, entries, numkeys, persist_to, replicate_to); couchbase_res->rc = retval; if (retval != LCB_SUCCESS) { if (retval == LCB_ETIMEDOUT) { zend_throw_exception(cb_timeout_exception, "Timed out waiting for the objects to persist", 0 TSRMLS_CC); } else { char errmsg[256]; snprintf(errmsg, sizeof(errmsg), "An error occured while waiting for the objects to persist: %s", lcb_strerror(couchbase_res->handle, retval)); zend_throw_exception(cb_lcb_exception, errmsg, 0 TSRMLS_CC); } } else { int currsize = 4096; char *errmsg = malloc(currsize); int offset = sprintf(errmsg, "The following documents was mutated:"); int errors = 0; for (ii = 0; ii < numkeys; ++ii) { if (entries[ii].mutated) { if ((offset + entries[ii].nkey + 3) > currsize) { char *p = realloc(errmsg, currsize * 2); if (p) { currsize *= 2; errmsg = p; } } if ((offset + entries[ii].nkey + 3) < currsize) { offset += sprintf(errmsg + offset, " \""); memcpy(errmsg + offset, entries[ii].key, entries[ii].nkey); offset += entries[ii].nkey; offset += sprintf(errmsg + offset, "\""); } errors = 1; } } if (errors) { zend_throw_exception(cb_key_mutated_exception, errmsg, 0 TSRMLS_CC); } free(errmsg); } } release_entry_array(entries, numkeys); efree(ctx); }
/* {{{ ftp_getdata */ databuf_t* ftp_getdata(ftpbuf_t *ftp) { int fd = -1; databuf_t *data; php_sockaddr_storage addr; struct sockaddr *sa; socklen_t size; union ipbox ipbox; char arg[sizeof("255, 255, 255, 255, 255, 255")]; struct timeval tv; /* ask for a passive connection if we need one */ if (ftp->pasv && !ftp_pasv(ftp, 1)) { return NULL; } /* alloc the data structure */ data = ecalloc(1, sizeof(*data)); data->listener = -1; data->fd = -1; data->type = ftp->type; sa = (struct sockaddr *) &ftp->localaddr; /* bind/listen */ if ((fd = socket(sa->sa_family, SOCK_STREAM, 0)) == SOCK_ERR) { php_error_docref(NULL, E_WARNING, "socket() failed: %s (%d)", strerror(errno), errno); goto bail; } /* passive connection handler */ if (ftp->pasv) { /* clear the ready status */ ftp->pasv = 1; /* connect */ /* Win 95/98 seems not to like size > sizeof(sockaddr_in) */ size = php_sockaddr_size(&ftp->pasvaddr); tv.tv_sec = ftp->timeout_sec; tv.tv_usec = 0; if (php_connect_nonb(fd, (struct sockaddr*) &ftp->pasvaddr, size, &tv) == -1) { php_error_docref(NULL, E_WARNING, "php_connect_nonb() failed: %s (%d)", strerror(errno), errno); goto bail; } data->fd = fd; ftp->data = data; return data; } /* active (normal) connection */ /* bind to a local address */ php_any_addr(sa->sa_family, &addr, 0); size = php_sockaddr_size(&addr); if (bind(fd, (struct sockaddr*) &addr, size) != 0) { php_error_docref(NULL, E_WARNING, "bind() failed: %s (%d)", strerror(errno), errno); goto bail; } if (getsockname(fd, (struct sockaddr*) &addr, &size) != 0) { php_error_docref(NULL, E_WARNING, "getsockname() failed: %s (%d)", strerror(errno), errno); goto bail; } if (listen(fd, 5) != 0) { php_error_docref(NULL, E_WARNING, "listen() failed: %s (%d)", strerror(errno), errno); goto bail; } data->listener = fd; #if HAVE_IPV6 && HAVE_INET_NTOP if (sa->sa_family == AF_INET6) { /* need to use EPRT */ char eprtarg[INET6_ADDRSTRLEN + sizeof("|x||xxxxx|")]; char out[INET6_ADDRSTRLEN]; inet_ntop(AF_INET6, &((struct sockaddr_in6*) sa)->sin6_addr, out, sizeof(out)); snprintf(eprtarg, sizeof(eprtarg), "|2|%s|%hu|", out, ntohs(((struct sockaddr_in6 *) &addr)->sin6_port)); if (!ftp_putcmd(ftp, "EPRT", eprtarg)) { goto bail; } if (!ftp_getresp(ftp) || ftp->resp != 200) { goto bail; } ftp->data = data; return data; } #endif /* send the PORT */ ipbox.ia[0] = ((struct sockaddr_in*) sa)->sin_addr; ipbox.s[2] = ((struct sockaddr_in*) &addr)->sin_port; snprintf(arg, sizeof(arg), "%u,%u,%u,%u,%u,%u", ipbox.c[0], ipbox.c[1], ipbox.c[2], ipbox.c[3], ipbox.c[4], ipbox.c[5]); if (!ftp_putcmd(ftp, "PORT", arg)) { goto bail; } if (!ftp_getresp(ftp) || ftp->resp != 200) { goto bail; } ftp->data = data; return data; bail: if (fd != -1) { closesocket(fd); } efree(data); return NULL; }
void mysqli_common_connect(INTERNAL_FUNCTION_PARAMETERS, zend_bool is_real_connect, zend_bool in_ctor) /* {{{ */ { MY_MYSQL *mysql = NULL; MYSQLI_RESOURCE *mysqli_resource = NULL; zval *object = getThis(); char *hostname = NULL, *username=NULL, *passwd=NULL, *dbname=NULL, *socket=NULL; size_t hostname_len = 0, username_len = 0, passwd_len = 0, dbname_len = 0, socket_len = 0; zend_bool persistent = FALSE; zend_long port = 0, flags = 0; zend_string *hash_key = NULL; zend_bool new_connection = FALSE; zend_resource *le; mysqli_plist_entry *plist = NULL; zend_bool self_alloced = 0; #if !defined(MYSQL_USE_MYSQLND) if ((MYSQL_VERSION_ID / 100) != (mysql_get_client_version() / 100)) { php_error_docref(NULL, E_WARNING, "Headers and client library minor version mismatch. Headers:%d Library:%ld", MYSQL_VERSION_ID, mysql_get_client_version()); } #endif if (getThis() && !ZEND_NUM_ARGS() && in_ctor) { php_mysqli_init(INTERNAL_FUNCTION_PARAM_PASSTHRU, in_ctor); return; } hostname = username = dbname = passwd = socket = NULL; if (!is_real_connect) { if (zend_parse_parameters(ZEND_NUM_ARGS(), "|ssssls", &hostname, &hostname_len, &username, &username_len, &passwd, &passwd_len, &dbname, &dbname_len, &port, &socket, &socket_len) == FAILURE) { return; } if (object && instanceof_function(Z_OBJCE_P(object), mysqli_link_class_entry)) { mysqli_resource = (Z_MYSQLI_P(object))->ptr; if (mysqli_resource && mysqli_resource->ptr) { mysql = (MY_MYSQL*) mysqli_resource->ptr; } } if (!mysql) { mysql = (MY_MYSQL *) ecalloc(1, sizeof(MY_MYSQL)); self_alloced = 1; } flags |= CLIENT_MULTI_RESULTS; /* needed for mysql_multi_query() */ } else { /* We have flags too */ if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "O|sssslsl", &object, mysqli_link_class_entry, &hostname, &hostname_len, &username, &username_len, &passwd, &passwd_len, &dbname, &dbname_len, &port, &socket, &socket_len, &flags) == FAILURE) { return; } mysqli_resource = (Z_MYSQLI_P(object))->ptr; MYSQLI_FETCH_RESOURCE_CONN(mysql, object, MYSQLI_STATUS_INITIALIZED); /* set some required options */ flags |= CLIENT_MULTI_RESULTS; /* needed for mysql_multi_query() */ /* remove some insecure options */ flags &= ~CLIENT_MULTI_STATEMENTS; /* don't allow multi_queries via connect parameter */ #if !defined(MYSQLI_USE_MYSQLND) if (PG(open_basedir) && PG(open_basedir)[0] != '\0') { flags &= ~CLIENT_LOCAL_FILES; } #endif } if (!socket_len || !socket) { socket = MyG(default_socket); } if (!port){ port = MyG(default_port); } if (!passwd) { passwd = MyG(default_pw); passwd_len = strlen(SAFE_STR(passwd)); } if (!username){ username = MyG(default_user); } if (!hostname || !hostname_len) { hostname = MyG(default_host); } if (mysql->mysql && mysqli_resource && (mysqli_resource->status > MYSQLI_STATUS_INITIALIZED)) { /* already connected, we should close the connection */ php_mysqli_close(mysql, MYSQLI_CLOSE_IMPLICIT, mysqli_resource->status); } if (strlen(SAFE_STR(hostname)) > 2 && !strncasecmp(hostname, "p:", 2)) { hostname += 2; if (!MyG(allow_persistent)) { php_error_docref(NULL, E_WARNING, "Persistent connections are disabled. Downgrading to normal"); } else { mysql->persistent = persistent = TRUE; hash_key = strpprintf(0, "mysqli_%s_%s" ZEND_LONG_FMT "%s%s%s", SAFE_STR(hostname), SAFE_STR(socket), port, SAFE_STR(username), SAFE_STR(dbname), SAFE_STR(passwd)); mysql->hash_key = hash_key; /* check if we can reuse exisiting connection ... */ if ((le = zend_hash_find_ptr(&EG(persistent_list), hash_key)) != NULL) { if (le->type == php_le_pmysqli()) { plist = (mysqli_plist_entry *) le->ptr; do { if (zend_ptr_stack_num_elements(&plist->free_links)) { mysql->mysql = zend_ptr_stack_pop(&plist->free_links); MyG(num_inactive_persistent)--; /* reset variables */ #ifndef MYSQLI_NO_CHANGE_USER_ON_PCONNECT if (!mysqli_change_user_silent(mysql->mysql, username, passwd, dbname, passwd_len)) { #else if (!mysql_ping(mysql->mysql)) { #endif #ifdef MYSQLI_USE_MYSQLND mysqlnd_restart_psession(mysql->mysql); #endif MyG(num_active_persistent)++; /* clear error */ php_mysqli_set_error(mysql_errno(mysql->mysql), (char *) mysql_error(mysql->mysql)); goto end; } else { mysqli_close(mysql->mysql, MYSQLI_CLOSE_IMPLICIT); mysql->mysql = NULL; } } } while (0); } } else { zend_resource le; le.type = php_le_pmysqli(); le.ptr = plist = calloc(1, sizeof(mysqli_plist_entry)); zend_ptr_stack_init_ex(&plist->free_links, 1); zend_hash_str_update_mem(&EG(persistent_list), ZSTR_VAL(hash_key), ZSTR_LEN(hash_key), &le, sizeof(le)); } }
static void _thread_mem_init(Datum* _thread) { if (_thread1data_inuse) {_thread[_gth]._pval = (double*)ecalloc(11, sizeof(double)); }else{ _thread[_gth]._pval = _thread1data; _thread1data_inuse = 1; } }
static zend_object *spl_dllist_object_new_ex(zend_class_entry *class_type, zval *orig, int clone_orig) /* {{{ */ { spl_dllist_object *intern; zend_class_entry *parent = class_type; int inherited = 0; intern = ecalloc(1, sizeof(spl_dllist_object) + zend_object_properties_size(parent)); zend_object_std_init(&intern->std, class_type); object_properties_init(&intern->std, class_type); intern->flags = 0; intern->traverse_position = 0; intern->debug_info = NULL; if (orig) { spl_dllist_object *other = Z_SPLDLLIST_P(orig); intern->ce_get_iterator = other->ce_get_iterator; if (clone_orig) { intern->llist = (spl_ptr_llist *)spl_ptr_llist_init(other->llist->ctor, other->llist->dtor); spl_ptr_llist_copy(other->llist, intern->llist); intern->traverse_pointer = intern->llist->head; SPL_LLIST_CHECK_ADDREF(intern->traverse_pointer); } else { intern->llist = other->llist; intern->traverse_pointer = intern->llist->head; SPL_LLIST_CHECK_ADDREF(intern->traverse_pointer); } intern->flags = other->flags; } else { intern->llist = (spl_ptr_llist *)spl_ptr_llist_init(spl_ptr_llist_zval_ctor, spl_ptr_llist_zval_dtor); intern->traverse_pointer = intern->llist->head; SPL_LLIST_CHECK_ADDREF(intern->traverse_pointer); } while (parent) { if (parent == spl_ce_SplStack) { intern->flags |= (SPL_DLLIST_IT_FIX | SPL_DLLIST_IT_LIFO); intern->std.handlers = &spl_handler_SplDoublyLinkedList; } else if (parent == spl_ce_SplQueue) { intern->flags |= SPL_DLLIST_IT_FIX; intern->std.handlers = &spl_handler_SplDoublyLinkedList; } if (parent == spl_ce_SplDoublyLinkedList) { intern->std.handlers = &spl_handler_SplDoublyLinkedList; break; } parent = parent->parent; inherited = 1; } if (!parent) { /* this must never happen */ php_error_docref(NULL, E_COMPILE_ERROR, "Internal compiler error, Class is not child of SplDoublyLinkedList"); } if (inherited) { intern->fptr_offset_get = zend_hash_str_find_ptr(&class_type->function_table, "offsetget", sizeof("offsetget") - 1); if (intern->fptr_offset_get->common.scope == parent) { intern->fptr_offset_get = NULL; } intern->fptr_offset_set = zend_hash_str_find_ptr(&class_type->function_table, "offsetset", sizeof("offsetset") - 1); if (intern->fptr_offset_set->common.scope == parent) { intern->fptr_offset_set = NULL; } intern->fptr_offset_has = zend_hash_str_find_ptr(&class_type->function_table, "offsetexists", sizeof("offsetexists") - 1); if (intern->fptr_offset_has->common.scope == parent) { intern->fptr_offset_has = NULL; } intern->fptr_offset_del = zend_hash_str_find_ptr(&class_type->function_table, "offsetunset", sizeof("offsetunset") - 1); if (intern->fptr_offset_del->common.scope == parent) { intern->fptr_offset_del = NULL; } intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1); if (intern->fptr_count->common.scope == parent) { intern->fptr_count = NULL; } } return &intern->std; }
/** * Open a phar file for streams API */ php_url* phar_parse_url(php_stream_wrapper *wrapper, char *filename, char *mode, int options TSRMLS_DC) /* {{{ */ { php_url *resource; char *arch = NULL, *entry = NULL, *error; int arch_len, entry_len; if (strlen(filename) < 7 || strncasecmp(filename, "phar://", 7)) { return NULL; } if (mode[0] == 'a') { if (!(options & PHP_STREAM_URL_STAT_QUIET)) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: open mode append not supported"); } return NULL; } if (phar_split_fname(filename, strlen(filename), &arch, &arch_len, &entry, &entry_len, 2, (mode[0] == 'w' ? 2 : 0) TSRMLS_CC) == FAILURE) { if (!(options & PHP_STREAM_URL_STAT_QUIET)) { if (arch && !entry) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: no directory in \"%s\", must have at least phar://%s/ for root directory (always use full path to a new phar)", filename, arch); arch = NULL; } else { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: invalid url or non-existent phar \"%s\"", filename); } } return NULL; } resource = ecalloc(1, sizeof(php_url)); resource->scheme = estrndup("phar", 4); resource->host = arch; resource->path = entry; #if MBO_0 if (resource) { fprintf(stderr, "Alias: %s\n", alias); fprintf(stderr, "Scheme: %s\n", resource->scheme); /* fprintf(stderr, "User: %s\n", resource->user);*/ /* fprintf(stderr, "Pass: %s\n", resource->pass ? "***" : NULL);*/ fprintf(stderr, "Host: %s\n", resource->host); /* fprintf(stderr, "Port: %d\n", resource->port);*/ fprintf(stderr, "Path: %s\n", resource->path); /* fprintf(stderr, "Query: %s\n", resource->query);*/ /* fprintf(stderr, "Fragment: %s\n", resource->fragment);*/ } #endif if (mode[0] == 'w' || (mode[0] == 'r' && mode[1] == '+')) { phar_archive_data **pphar = NULL, *phar; if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.arBuckets && FAILURE == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **)&pphar)) { pphar = NULL; } if (PHAR_G(readonly) && (!pphar || !(*pphar)->is_data)) { if (!(options & PHP_STREAM_URL_STAT_QUIET)) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "phar error: write operations disabled by the php.ini setting phar.readonly"); } php_url_free(resource); return NULL; } if (phar_open_or_create_filename(resource->host, arch_len, NULL, 0, 0, options, &phar, &error TSRMLS_CC) == FAILURE) { if (error) { if (!(options & PHP_STREAM_URL_STAT_QUIET)) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "%s", error); } efree(error); } php_url_free(resource); return NULL; } if (phar->is_persistent && FAILURE == phar_copy_on_write(&phar TSRMLS_CC)) { if (error) { spprintf(&error, 0, "Cannot open cached phar '%s' as writeable, copy on write failed", resource->host); if (!(options & PHP_STREAM_URL_STAT_QUIET)) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "%s", error); } efree(error); } php_url_free(resource); return NULL; } } else { if (phar_open_from_filename(resource->host, arch_len, NULL, 0, options, NULL, &error TSRMLS_CC) == FAILURE) { if (error) { if (!(options & PHP_STREAM_URL_STAT_QUIET)) { php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "%s", error); } efree(error); } php_url_free(resource); return NULL; } } return resource; }
static struct ldentry * pw2entry( struct ldop *op, struct passwd *pw ) { struct ldentry *entry; struct ldattr *attr; int i; entry = (struct ldentry *) ecalloc( 1, sizeof( struct ldentry )); /* * construct the DN from pw_name */ if ( strchr( op->ldop_suffixes[ 0 ], '=' ) != NULL ) { /* * X.500 style DN */ sprintf( tmpbuf, "cn=%s, %s", pw->pw_name, op->ldop_suffixes[ 0 ] ); } else { /* * RFC-822 style DN */ sprintf( tmpbuf, "%s@%s", pw->pw_name, op->ldop_suffixes[ 0 ] ); } entry->lde_dn = estrdup( tmpbuf ); /* * for now, we simply derive the LDAP attribute values as follows: * objectClass = person * uid = pw_name * sn = pw_name * cn = pw_name * cn = pw_gecos (second common name) */ entry->lde_attrs = (struct ldattr **)ecalloc( 5, sizeof( struct ldattr * )); i = 0; attr = (struct ldattr *)ecalloc( 1, sizeof( struct ldattr )); attr->lda_name = estrdup( "objectClass" ); attr->lda_values = (char **)ecalloc( 2, sizeof( char * )); attr->lda_values[ 0 ] = estrdup( "person" ); entry->lde_attrs[ i++ ] = attr; attr = (struct ldattr *)ecalloc( 1, sizeof( struct ldattr )); attr->lda_name = estrdup( "uid" ); attr->lda_values = (char **)ecalloc( 2, sizeof( char * )); attr->lda_values[ 0 ] = estrdup( pw->pw_name ); entry->lde_attrs[ i++ ] = attr; attr = (struct ldattr *)ecalloc( 1, sizeof( struct ldattr )); attr->lda_name = estrdup( "sn" ); attr->lda_values = (char **)ecalloc( 2, sizeof( char * )); attr->lda_values[ 0 ] = estrdup( pw->pw_name ); entry->lde_attrs[ i++ ] = attr; attr = (struct ldattr *)ecalloc( 1, sizeof( struct ldattr )); attr->lda_name = estrdup( "cn" ); attr->lda_values = (char **)ecalloc( 3, sizeof( char * )); attr->lda_values[ 0 ] = estrdup( pw->pw_name ); if ( pw->pw_gecos != NULL && *pw->pw_gecos != '\0' ) { attr->lda_values[ 1 ] = estrdup( pw->pw_gecos ); } entry->lde_attrs[ i++ ] = attr; return( entry ); }
zend_object_std_dtor (&intern->std); if ( intern->db != NULL && intern->db->rsrc ) { zend_list_close (intern->db->rsrc); } } static void geoip_object_new (zend_class_entry *class_type, zend_object_handlers *handlers, zend_object **retval TSRMLS_DC) { geoip_object * intern; zval * tmp; GE_PRINT_CALL_API_NAME; intern = ecalloc (1, sizeof (geoip_object) + zend_object_properties_size (class_type)); zend_object_std_init (&intern->std,class_type TSRMLS_CC); handlers->offset = XtOffsetOf(geoip_object, std); handlers->free_obj = (zend_object_free_obj_t) geoip_object_free_storage; intern->std.handlers = handlers; *retval = &intern->std; } static zend_object * geoip_object_new_main (zend_class_entry * class_type TSRMLS_DC) { zend_object * retval; GE_PRINT_CALL_API_NAME; geoip_object_new (class_type, &geoip_object_handlers, &retval TSRMLS_CC); return retval;
static void _thread_mem_init(Datum* _thread) { _thread[_dith1]._pval = (double*)ecalloc(2, sizeof(double)); _newtonspace1 = nrn_cons_newtonspace(1); }
/* {{{ php_url_parse */ PHPAPI php_url *php_url_parse_ex(char const *str, size_t length) { char port_buf[6]; php_url *ret = ecalloc(1, sizeof(php_url)); char const *s, *e, *p, *pp, *ue; s = str; ue = s + length; /* parse scheme */ if ((e = memchr(s, ':', length)) && e != s) { /* validate scheme */ p = s; while (p < e) { /* scheme = 1*[ lowalpha | digit | "+" | "-" | "." ] */ if (!isalpha(*p) && !isdigit(*p) && *p != '+' && *p != '.' && *p != '-') { if (e + 1 < ue && e < s + strcspn(s, "?#")) { goto parse_port; } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */ s += 2; e = 0; goto parse_host; } else { goto just_path; } } p++; } if (e + 1 == ue) { /* only scheme is available */ ret->scheme = zend_string_init(s, (e - s), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme)); return ret; } /* * certain schemas like mailto: and zlib: may not have any / after them * this check ensures we support those. */ if (*(e+1) != '/') { /* check if the data we get is a port this allows us to * correctly parse things like a.com:80 */ p = e + 1; while (p < ue && isdigit(*p)) { p++; } if ((p == ue || *p == '/') && (p - e) < 7) { goto parse_port; } ret->scheme = zend_string_init(s, (e-s), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme)); s = e + 1; goto just_path; } else { ret->scheme = zend_string_init(s, (e-s), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->scheme), ZSTR_LEN(ret->scheme)); if (e + 2 < ue && *(e + 2) == '/') { s = e + 3; if (zend_string_equals_literal_ci(ret->scheme, "file")) { if (e + 3 < ue && *(e + 3) == '/') { /* support windows drive letters as in: file:///c:/somedir/file.txt */ if (e + 5 < ue && *(e + 5) == ':') { s = e + 4; } goto just_path; } } } else { s = e + 1; goto just_path; } } } else if (e) { /* no scheme; starts with colon: look for port */ parse_port: p = e + 1; pp = p; while (pp < ue && pp - p < 6 && isdigit(*pp)) { pp++; } if (pp - p > 0 && pp - p < 6 && (pp == ue || *pp == '/')) { zend_long port; memcpy(port_buf, p, (pp - p)); port_buf[pp - p] = '\0'; port = ZEND_STRTOL(port_buf, NULL, 10); if (port > 0 && port <= 65535) { ret->port = (unsigned short) port; if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */ s += 2; } } else { php_url_free(ret); return NULL; } } else if (p == pp && pp == ue) { php_url_free(ret); return NULL; } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */ s += 2; } else { goto just_path; } } else if (s + 1 < ue && *s == '/' && *(s + 1) == '/') { /* relative-scheme URL */ s += 2; } else { goto just_path; } parse_host: /* Binary-safe strcspn(s, "/?#") */ e = ue; if ((p = memchr(s, '/', e - s))) { e = p; } if ((p = memchr(s, '?', e - s))) { e = p; } if ((p = memchr(s, '#', e - s))) { e = p; } /* check for login and password */ if ((p = zend_memrchr(s, '@', (e-s)))) { if ((pp = memchr(s, ':', (p-s)))) { ret->user = zend_string_init(s, (pp-s), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->user), ZSTR_LEN(ret->user)); pp++; ret->pass = zend_string_init(pp, (p-pp), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->pass), ZSTR_LEN(ret->pass)); } else { ret->user = zend_string_init(s, (p-s), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->user), ZSTR_LEN(ret->user)); } s = p + 1; } /* check for port */ if (s < ue && *s == '[' && *(e-1) == ']') { /* Short circuit portscan, we're dealing with an IPv6 embedded address */ p = NULL; } else { p = zend_memrchr(s, ':', (e-s)); } if (p) { if (!ret->port) { p++; if (e-p > 5) { /* port cannot be longer then 5 characters */ php_url_free(ret); return NULL; } else if (e - p > 0) { zend_long port; memcpy(port_buf, p, (e - p)); port_buf[e - p] = '\0'; port = ZEND_STRTOL(port_buf, NULL, 10); if (port > 0 && port <= 65535) { ret->port = (unsigned short)port; } else { php_url_free(ret); return NULL; } } p--; } } else { p = e; } /* check if we have a valid host, if we don't reject the string as url */ if ((p-s) < 1) { php_url_free(ret); return NULL; } ret->host = zend_string_init(s, (p-s), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->host), ZSTR_LEN(ret->host)); if (e == ue) { return ret; } s = e; just_path: e = ue; p = memchr(s, '#', (e - s)); if (p) { p++; if (p < e) { ret->fragment = zend_string_init(p, (e - p), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->fragment), ZSTR_LEN(ret->fragment)); } e = p-1; } p = memchr(s, '?', (e - s)); if (p) { p++; if (p < e) { ret->query = zend_string_init(p, (e - p), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->query), ZSTR_LEN(ret->query)); } e = p-1; } if (s < e || s == ue) { ret->path = zend_string_init(s, (e - s), 0); php_replace_controlchars_ex(ZSTR_VAL(ret->path), ZSTR_LEN(ret->path)); } return ret; }
void load_net () { char ** cpp; unsigned int l; ARCM pp1, pp2; ROWP p_inh, rwp; char linebuf[LINEMAX]; float ftemp, x, y; int group_num, i,j, knd, noar, mark, nomp, norp; #define VBAR '|' #ifdef DEBUG printf(" Start of load_net\n"); #endif /* skip first line containing '|0|' */ fgets(linebuf, LINEMAX, nfp); /* skip comment */ for ( ; ; ) { fgets(linebuf, LINEMAX, nfp); if ( linebuf[0] == VBAR ) break; } /* read number of objects in the net */ fscanf(nfp,"f %d %d %d",&nomp,&place_num,&norp); fscanf(nfp,"%d %d %d %d\n",&trans_num,&group_num,&i,&j); l = trans_num+trans_num+1; mparp = (ROWP)ecalloc(nomp,short_SIZE); pp1 = p_inp = (ARCM)ecalloc(place_num,ROWP_SIZE); pp2 = p_out = (ARCM)ecalloc(place_num,ROWP_SIZE); for ( i = place_num ; i-- ; pp1++, pp2++ ) { register ROWP cp; *pp1 = cp = (ROWP)ecalloc(l,ROWT_SIZE); *cp = 0; *pp2 = cp = (ROWP)ecalloc(l,ROWT_SIZE); *cp = 0; } p_inh = (ROWP)ecalloc(l,ROWT_SIZE); *p_inh = 0; #ifdef DEBUG printf(" %d marking parameters\n", nomp); #endif /* read marking parameters */ { register int i = 0; unsigned int mark; while ( i < nomp ) { getname( linebuf ); fscanf(nfp,"%d",&mark); while ( getc(nfp) != '\n' ); #ifdef DEBUG printf(" %d %s=%d\n", i, linebuf, mark); #endif mparp[i++] = (ROWT)mark; } } /* read places */ cpp = place_nam = (char**)ecalloc(place_num,sizeof(char*)); rwp = M0 = (ROWP)ecalloc(place_num,short_SIZE); for ( i = place_num ; i-- ; cpp++, rwp++ ) { getname( linebuf ); fscanf(nfp,"%d ",&mark); while ( getc(nfp) != '\n' ); if ( mark < 0 ) mark = mparp[-1-mark]; #ifdef DEBUG printf(" place %s %d\n", linebuf, mark ); #endif *cpp = ecalloc(strlen(linebuf)+1,1); strcpy(*cpp,linebuf); *rwp = (short)mark; } /* skip rate parameters */ i = 1; while ( i++ <= norp ) { getname( linebuf ); fscanf(nfp,"%f",&ftemp); while ( getc(nfp) != '\n' ); } /* skip groups */ i = 1; while ( i++ <= group_num ) { getname( linebuf ); fscanf(nfp,"%f %f",&x,&y); while ( getc(nfp) != '\n' ); } /* read transitions */ cpp = trans_nam = (char**)ecalloc(trans_num+1,sizeof(char*)); for ( i = trans_num, cpp++ ; i-- ; cpp++ ) { getname( linebuf ); *cpp = ecalloc(strlen(linebuf)+1,1); strcpy(*cpp,linebuf); fscanf(nfp,"%f %d %d %d ", &ftemp,&mark,&knd,&noar ); while ( getc(nfp) != '\n' ); if ( mark < 0 ) { int ii; ii = mark = -mark; while ( --ii ) { while ( getc(nfp) != '\n' ); } } getarcs(p_out,noar,trans_num-i, *cpp, 1); fscanf(nfp,"%d\n",&noar); getarcs(p_inp,noar,trans_num-i, *cpp, 0); fscanf(nfp,"%d\n",&noar); getarcs(&p_inh,noar,trans_num-i, *cpp, -1); *p_inh = 0; } #ifdef DEBUG printf(" End of load_net\n"); #endif }
PHP_COUCHBASE_LOCAL void php_couchbase_get_delayed_impl(INTERNAL_FUNCTION_PARAMETERS, int oo) /* {{{ */ { zval *res, *akeys; long with_cas = 0; lcb_time_t exp = {0}; long expiry = 0; zend_bool lock = 0; int argflags = PHP_COUCHBASE_ARG_F_ASYNC; php_couchbase_res *couchbase_res; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2 zend_fcall_info fci = {0}; zend_fcall_info_cache fci_cache = {0}; if (oo) { argflags |= PHP_COUCHBASE_ARG_F_OO; } else { argflags |= PHP_COUCHBASE_ARG_F_FUNCTIONAL; } PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "a|lf!lb", &akeys, &with_cas, &fci, &fci_cache, &expiry, &lock); #else if (oo) { argflags |= PHP_COUCHBASE_ARG_F_OO; } else { argflags |= PHP_COUCHBASE_ARG_F_FUNCTIONAL; } zval *callback = NULL; PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "a|lzlb", &akeys, &with_cas, &callback, &expiry, &lock); if (callback && Z_TYPE_P(callback) != IS_NULL && !zend_is_callable(callback, 0, NULL)) { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo, cb_exception, "third argument is expected to be a valid callback"); return; } #endif { zval **ppzval; lcb_error_t retval; php_couchbase_ctx *ctx; char **keys; long nkey, *klens, i; nkey = zend_hash_num_elements(Z_ARRVAL_P(akeys)); keys = ecalloc(nkey, sizeof(char *)); klens = ecalloc(nkey, sizeof(long)); for (i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys)), i++) { if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { nkey--; continue; } if (IS_ARRAY != Z_TYPE_PP(ppzval)) { convert_to_string_ex(ppzval); } if (!Z_STRLEN_PP(ppzval)) { nkey--; continue; } if (couchbase_res->prefix_key_len) { klens[i] = spprintf(&(keys[i]), 0, "%s_%s", couchbase_res->prefix_key, Z_STRVAL_PP(ppzval)); } else { keys[i] = Z_STRVAL_PP(ppzval); klens[i] = Z_STRLEN_PP(ppzval); } } if (!nkey) { efree(keys); efree(klens); return; } couchbase_res->seqno += nkey; ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->flags = with_cas; { lcb_get_cmd_t **commands = ecalloc(nkey, sizeof(lcb_get_cmd_t *)); int ii; if (expiry) { exp = pcbc_check_expiry(expiry); } for (ii = 0; ii < nkey; ++ii) { lcb_get_cmd_t *cmd = ecalloc(1, sizeof(lcb_get_cmd_t)); commands[ii] = cmd; cmd->v.v0.key = keys[ii]; cmd->v.v0.nkey = klens[ii]; cmd->v.v0.lock = (int)lock; cmd->v.v0.exptime = exp; /* NB: this assumes that sizeof(lcb_time_t) == sizeof(long) */ } retval = lcb_get(couchbase_res->handle, ctx, nkey, (const lcb_get_cmd_t * const *)commands); for (ii = 0; ii < nkey; ++ii) { efree(commands[ii]); } efree(commands); } if (LCB_SUCCESS != retval) { if (couchbase_res->prefix_key_len) { int i; for (i = 0; i < nkey; i++) { efree(keys[i]); } } efree(keys); efree(klens); efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo, cb_lcb_exception, "Failed to schedule delayed get request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } couchbase_res->async = 1; couchbase_res->async_ctx = ctx; if (couchbase_res->prefix_key_len) { int i; for (i = 0; i < nkey; i++) { efree(keys[i]); } } efree(keys); efree(klens); if ( #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2 fci.size #else callback #endif ) { zval *result, **ppzval, *retval_ptr = NULL; zval **params[2]; MAKE_STD_ZVAL(result); array_init(result); ctx->rv = result; pcbc_start_loop(couchbase_res); couchbase_res->async = 0; for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(result)); zend_hash_has_more_elements(Z_ARRVAL_P(result)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(result))) { if (zend_hash_get_current_data(Z_ARRVAL_P(result), (void **)&ppzval) == FAILURE) { continue; } params[0] = &res; params[1] = ppzval; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2 fci.retval_ptr_ptr = &retval_ptr; fci.param_count = 2; fci.params = params; zend_call_function(&fci, &fci_cache TSRMLS_CC); #else call_user_function_ex(EG(function_table), NULL, callback, &retval_ptr, 2, params, 0, NULL TSRMLS_CC); #endif if (retval_ptr != NULL) { zval_ptr_dtor(&retval_ptr); } } zval_ptr_dtor(&result); efree(ctx); } } RETURN_TRUE; }
#ifdef HAVE_CONFIG_H #include "config.h" #endif #include "php.h" #include "php_yar.h" #include "yar_exception.h" #include "yar_response.h" #include "yar_request.h" yar_request_t * php_yar_request_instance(zval *body TSRMLS_DC) /* {{{ */ { yar_request_t *req; zval **ppzval; HashTable *ht; req = (yar_request_t *)ecalloc(sizeof(yar_request_t), 1); if (IS_ARRAY != Z_TYPE_P(body)) { return req; } ht = Z_ARRVAL_P(body); if (zend_hash_find(ht, "i", sizeof("i"), (void**)&ppzval) == SUCCESS) { if (IS_LONG != Z_TYPE_PP(ppzval)) { convert_to_long(*ppzval); } req->id = Z_LVAL_PP(ppzval); } if (zend_hash_find(ht, "m", sizeof("m"), (void**)&ppzval) == SUCCESS) { if (IS_STRING != Z_TYPE_PP(ppzval)) {
PHP_COUCHBASE_LOCAL void php_couchbase_store_impl(INTERNAL_FUNCTION_PARAMETERS, lcb_storage_t op, int multi) { lcb_error_t retval; php_couchbase_res *couchbase_res; php_couchbase_ctx *ctx; time_t exp = {0}; unsigned int flags = 0; char *payload, *cas = NULL; size_t payload_len = 0; unsigned long long cas_v = 0; long expire = 0, cas_len = 0; if (multi) { /* multi-get */ zval *akeys, **ppzval; char *key = NULL; uint klen = 0; ulong idx; int key_type, nkey = 0; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_FUNCTIONAL, "a|l", &akeys, &expire); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, expire, &exp) == -1) { /* Incorrect expiry time */ return; } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; array_init(ctx->rv); for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys))) { if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { continue; } switch ((key_type = zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, &idx, 0))) { case HASH_KEY_IS_LONG: spprintf(&key, 0, "%ld", idx); break; case HASH_KEY_IS_STRING: break; default: continue; } if (!(klen = strlen(key))) { continue; } payload = php_couchbase_zval_to_payload(*ppzval, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { RETURN_FALSE; } if (couchbase_res->prefix_key_len) { char *new_key; klen = spprintf(&new_key, 0, "%s_%s", couchbase_res->prefix_key, key); if (key_type == HASH_KEY_IS_LONG) { efree(key); } key = new_key; } { lcb_store_cmd_t cmd; lcb_store_cmd_t *commands[] = { &cmd }; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.operation = op; cmd.v.v0.key = key; cmd.v.v0.nkey = klen; cmd.v.v0.bytes = payload; cmd.v.v0.nbytes = payload_len; cmd.v.v0.flags = flags; cmd.v.v0.exptime = exp; retval = lcb_store(couchbase_res->handle, ctx, 1, (const lcb_store_cmd_t * const *)commands); } efree(payload); if (couchbase_res->prefix_key_len || HASH_KEY_IS_LONG == key_type) { efree(key); } if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } nkey++; } if (!nkey) { efree(ctx); return; } couchbase_res->seqno += nkey; } else { /* single-get */ char *key = NULL; zval *value; long klen = 0; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_FUNCTIONAL, "sz|ls", &key, &klen, &value, &expire, &cas, &cas_len); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, expire, &exp) == -1) { /* Incorrect expiry time */ return; } if (!klen) { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_illegal_key_exception, "No key specified: Empty key"); return; } if (cas) { char *e; cas_v = (lcb_cas_t)strtoull(cas, &e, 10); if (*e != '\0') { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_illegal_key_exception, "Invalid CAS specified"); return; } } payload = php_couchbase_zval_to_payload(value, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { RETURN_FALSE; } if (couchbase_res->prefix_key_len) { klen = spprintf(&key, 0, "%s_%s", couchbase_res->prefix_key, key); } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; couchbase_res->seqno += 1; { lcb_store_cmd_t cmd; lcb_store_cmd_t *commands[] = { &cmd }; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.operation = op; cmd.v.v0.key = key; cmd.v.v0.nkey = klen; cmd.v.v0.bytes = payload; cmd.v.v0.nbytes = payload_len; cmd.v.v0.flags = flags; cmd.v.v0.exptime = exp; cmd.v.v0.cas = (uint64_t)cas_v; retval = lcb_store(couchbase_res->handle, ctx, 1, (const lcb_store_cmd_t * const *)commands); } efree(payload); if (couchbase_res->prefix_key_len) { efree(key); } if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } } { pcbc_start_loop(couchbase_res); if (IS_ARRAY != Z_TYPE_P(return_value)) { if (LCB_SUCCESS != ctx->res->rc) { RETVAL_FALSE; switch (op) { case LCB_ADD: if (LCB_KEY_EEXISTS == ctx->res->rc) { break; } case LCB_APPEND: case LCB_PREPEND: if (LCB_NOT_STORED == ctx->res->rc) { break; } case LCB_REPLACE: case LCB_SET: if (LCB_KEY_ENOENT == ctx->res->rc) { break; } if (cas && LCB_KEY_EEXISTS == ctx->res->rc) { break; } default: couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to store a value to server: %s", lcb_strerror(couchbase_res->handle, ctx->res->rc)); break; } } } efree(ctx); } }