/* {{{ proto void DOMXPath::__construct(DOMDocument doc) U */ PHP_METHOD(domxpath, __construct) { zval *id, *doc; xmlDocPtr docp = NULL; dom_object *docobj; dom_xpath_object *intern; xmlXPathContextPtr ctx, oldctx; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC); if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO", &id, dom_xpath_class_entry, &doc, dom_document_class_entry) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); DOM_GET_OBJ(docp, doc, xmlDocPtr, docobj); ctx = xmlXPathNewContext(docp); if (ctx == NULL) { php_dom_throw_error(INVALID_STATE_ERR, 1 TSRMLS_CC); RETURN_FALSE; } intern = (dom_xpath_object *)zend_object_store_get_object(id TSRMLS_CC); if (intern != NULL) { oldctx = (xmlXPathContextPtr)intern->ptr; if (oldctx != NULL) { php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC); xmlXPathFreeContext(oldctx); } xmlXPathRegisterFuncNS (ctx, (const xmlChar *) "functionString", (const xmlChar *) "http://php.net/xpath", dom_xpath_ext_function_string_php); xmlXPathRegisterFuncNS (ctx, (const xmlChar *) "function", (const xmlChar *) "http://php.net/xpath", dom_xpath_ext_function_object_php); intern->ptr = ctx; ctx->userData = (void *)intern; intern->document = docobj->document; php_libxml_increment_doc_ref((php_libxml_node_object *)intern, docp TSRMLS_CC); } }
/* ArchiveReader::close {{{ * */ ZEND_METHOD(ArchiveReader, close) { zval *this = getThis(); int resourse_id; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC); if ((resourse_id = _archive_get_rsrc_id(this TSRMLS_CC))) { add_property_resource(this, "fd", 0); zend_list_delete(resourse_id); zend_restore_error_handling(&error_handling TSRMLS_CC); RETURN_TRUE; } php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to close archive file descriptor"); zend_restore_error_handling(&error_handling TSRMLS_CC); }
/* {{{ proto MongoDB\Driver\CursorId CursorId::__construct(string $id) Construct a new CursorId */ PHP_METHOD(CursorId, __construct) { php_phongo_cursorid_t *intern; zend_error_handling error_handling; char *id; int id_len; (void)return_value; (void)return_value_ptr; (void)return_value_used; zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); intern = (php_phongo_cursorid_t *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &id, &id_len) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); }
/* {{{ proto MongoUpdateBatch MongoUpdateBatch::__construct(MongoCollection $collection [, array $write_options]) Constructs a new Write Batch of $batch_type operations */ PHP_METHOD(MongoUpdateBatch, __construct) { zend_error_handling error_handling; mongo_write_batch_object *intern; HashTable *write_options = NULL; zval *zcollection; zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC); intern = (mongo_write_batch_object*)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|h", &zcollection, mongo_ce_Collection, &write_options) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); php_mongo_api_batch_ctor(intern, zcollection, MONGODB_API_COMMAND_UPDATE, write_options TSRMLS_CC); }
/* {{{ proto MongoDB\Driver\ReadPreference ReadPreference::__construct(integer $readPreference[, array $tagSets = array()]) Constructs a new ReadPreference */ PHP_METHOD(ReadPreference, __construct) { php_phongo_readpreference_t *intern; zend_error_handling error_handling; long readPreference; zval *tagSets = NULL; (void)return_value_ptr; (void)return_value; (void)return_value_used; zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); intern = (php_phongo_readpreference_t *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|a!", &readPreference, &tagSets) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); switch(readPreference) { case MONGOC_READ_PRIMARY: case MONGOC_READ_SECONDARY: case MONGOC_READ_PRIMARY_PREFERRED: case MONGOC_READ_SECONDARY_PREFERRED: case MONGOC_READ_NEAREST: intern->read_preference = mongoc_read_prefs_new(readPreference); if (tagSets) { bson_t *tags = bson_new(); zval_to_bson(tagSets, PHONGO_BSON_NONE, (bson_t *)tags, NULL TSRMLS_CC); mongoc_read_prefs_set_tags(intern->read_preference, tags); bson_destroy(tags); if (!mongoc_read_prefs_is_valid(intern->read_preference)) { phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT TSRMLS_CC, "%s", "Invalid tagSet"); return; } } break; default: phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT TSRMLS_CC, "%s", "Invalid ReadPreference"); return; } }
/* {{{ proto MongoDB\Driver\Result Result::__construct(MongoDB\Driver\Server $server, array|object $responseDocument) Constructs a new Result */ PHP_METHOD(Result, __construct) { php_phongo_result_t *intern; zend_error_handling error_handling; zval *server; zval *responseDocument; (void)return_value; (void)return_value_ptr; (void)return_value_used; zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); intern = (php_phongo_result_t *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OA", &server, php_phongo_server_ce, &responseDocument) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); }
/* {{{ proto MongoDB\WriteResult WriteException::getWriteResult() Returns the WriteResult from the failed write operation. */ PHP_METHOD(WriteException, getWriteResult) { zend_error_handling error_handling; zval *writeresult; zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); if (zend_parse_parameters_none() == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); writeresult = zend_read_property(php_phongo_writeexception_ce, getThis(), ZEND_STRL("writeResult"), 0 TSRMLS_CC); RETURN_ZVAL(writeresult, 1, 0); }
/* ArchiveReader::skipCurrentEntryData{{{ * */ ZEND_METHOD(ArchiveReader, skipCurrentEntryData){ zval *this = getThis(); archive_file_t *arch; zend_error_handling error_handling; int r; zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC); if (!_archive_get_fd(this, &arch TSRMLS_CC)) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } r = archive_read_data_skip(arch->arch); if(r != ARCHIVE_OK){ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Skip archive entry failed"); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } return; }/*}}}*/
/* {{{ proto MongoDB\Query Query::__construct(array|object $filter[, array $options = array()]) Constructs a new Query */ PHP_METHOD(Query, __construct) { php_phongo_query_t *intern; zend_error_handling error_handling; zval *filter; zval *options = NULL; zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); intern = (php_phongo_query_t *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "A|a!", &filter, &options) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); phongo_query_init(intern, filter, options TSRMLS_CC); }
/* {{{ proto BSON\Timestamp Timestamp::__construct(integer $increment, int $timestamp) Construct a new BSON Timestamp (4bytes increment, 4bytes timestamp) */ PHP_METHOD(Timestamp, __construct) { php_phongo_timestamp_t *intern; zend_error_handling error_handling; long increment; long timestamp; zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); intern = Z_TIMESTAMP_OBJ_P(getThis()); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &increment, ×tamp) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); intern->increment = increment; intern->timestamp = timestamp; }
/* {{{ proto void DOMAttr::__construct(string name, [string value]); */ PHP_METHOD(domattr, __construct) { zval *id; xmlAttrPtr nodep = NULL; xmlNodePtr oldnode = NULL; dom_object *intern; char *name, *value = NULL; int name_len, value_len, name_valid; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC); if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|s", &id, dom_attr_class_entry, &name, &name_len, &value, &value_len) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC); name_valid = xmlValidateName((xmlChar *) name, 0); if (name_valid != 0) { php_dom_throw_error(INVALID_CHARACTER_ERR, 1 TSRMLS_CC); RETURN_FALSE; } nodep = xmlNewProp(NULL, (xmlChar *) name, value); if (!nodep) { php_dom_throw_error(INVALID_STATE_ERR, 1 TSRMLS_CC); RETURN_FALSE; } if (intern != NULL) { oldnode = dom_object_get_node(intern); if (oldnode != NULL) { php_libxml_node_free_resource(oldnode TSRMLS_CC); } php_libxml_increment_node_ptr((php_libxml_node_object *)intern, (xmlNodePtr)nodep, (void *)intern TSRMLS_CC); } }
/* {{{ proto void DOMEntityReference::__construct(string name); */ PHP_METHOD(domentityreference, __construct) { zval *id; xmlNode *node; xmlNodePtr oldnode = NULL; dom_object *intern; char *name; size_t name_len, name_valid; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling); if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Os", &id, dom_entityreference_class_entry, &name, &name_len) == FAILURE) { zend_restore_error_handling(&error_handling); return; } zend_restore_error_handling(&error_handling); name_valid = xmlValidateName((xmlChar *) name, 0); if (name_valid != 0) { php_dom_throw_error(INVALID_CHARACTER_ERR, 1); RETURN_FALSE; } node = xmlNewReference(NULL, (xmlChar *) name); if (!node) { php_dom_throw_error(INVALID_STATE_ERR, 1); RETURN_FALSE; } intern = Z_DOMOBJ_P(id); if (intern != NULL) { oldnode = dom_object_get_node(intern); if (oldnode != NULL) { php_libxml_node_free_resource(oldnode ); } php_libxml_increment_node_ptr((php_libxml_node_object *)intern, node, (void *)intern); } }
/** * {{{ proto bool SolrInputDocument::setVersion(int version) * Enable optimistic concurrency using assertions */ PHP_METHOD(SolrInputDocument, setVersion) { long version = 0; solr_document_t *doc_entry = NULL; solr_field_list_t *field = NULL; solr_char_t *field_name = "_version_"; COMPAT_ARG_SIZE_T field_name_length = sizeof("_version_"); char version_str[80]; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, solr_ce_SolrIllegalArgumentException, &error_handling TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &version) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); if (solr_fetch_document_entry(getThis(), &doc_entry TSRMLS_CC) == FAILURE) { return; } field = pemalloc(sizeof(solr_field_list_t), SOLR_DOCUMENT_FIELD_PERSISTENT); field->count = 0L; field->field_boost = 0.0f; field->field_name = pestrdup(field_name, SOLR_DOCUMENT_FIELD_PERSISTENT); field->head = field->last = NULL; snprintf(version_str, 80, "%ld", version); solr_document_insert_field_value(field, version_str, 0.0); if ((zend_hash_str_update_ptr(doc_entry->fields, field_name, field_name_length, field) == NULL )) { solr_throw_exception_ex(solr_ce_SolrException, SOLR_ERROR_1008 TSRMLS_CC, SOLR_FILE_LINE_FUNC, SOLR_ERROR_1008_MSG); solr_destroy_field_list(&field); return; } RETURN_TRUE; }
/* {{{ proto BSON\Binary Binary::__construct(string $data, int $type) Construct a new BSON Binary type */ PHP_METHOD(Binary, __construct) { php_phongo_binary_t *intern; zend_error_handling error_handling; char *data; int data_len; long type; zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); intern = (php_phongo_binary_t *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &data, &data_len, &type) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); intern->data = estrndup(data, data_len); intern->data_len = data_len; intern->type = type; }
/* {{{ proto Spoofchecker::__construct() * Spoofchecker object constructor. */ PHP_METHOD(Spoofchecker, __construct) { #if U_ICU_VERSION_MAJOR_NUM < 58 int checks; #endif zend_error_handling error_handling; SPOOFCHECKER_METHOD_INIT_VARS; if (zend_parse_parameters_none_throw() == FAILURE) { return; } zend_replace_error_handling(EH_THROW, IntlException_ce_ptr, &error_handling); SPOOFCHECKER_METHOD_FETCH_OBJECT_NO_CHECK; co->uspoof = uspoof_open(SPOOFCHECKER_ERROR_CODE_P(co)); INTL_METHOD_CHECK_STATUS(co, "spoofchecker: unable to open ICU Spoof Checker"); #if U_ICU_VERSION_MAJOR_NUM >= 58 /* TODO save it into the object for further suspiction check comparison. */ /* ICU 58 removes WSC and MSC handling. However there are restriction levels as defined in http://www.unicode.org/reports/tr39/tr39-15.html#Restriction_Level_Detection and the default is high restrictive. In further, we might want to utilize uspoof_check2 APIs when it became stable, to use extended check result APIs. Subsequent changes in the unicode security algos are to be watched.*/ uspoof_setRestrictionLevel(co->uspoof, SPOOFCHECKER_DEFAULT_RESTRICTION_LEVEL); #else /* Single-script enforcement is on by default. This fails for languages like Japanese that legally use multiple scripts within a single word, so we turn it off. */ checks = uspoof_getChecks(co->uspoof, SPOOFCHECKER_ERROR_CODE_P(co)); uspoof_setChecks(co->uspoof, checks & ~USPOOF_SINGLE_SCRIPT, SPOOFCHECKER_ERROR_CODE_P(co)); #endif zend_restore_error_handling(&error_handling); }
/* {{{ proto MongoDB\Driver\Query Query::__construct(array|object $filter[, array $options = array()]) Constructs a new Query */ PHP_METHOD(Query, __construct) { php_phongo_query_t *intern; zend_error_handling error_handling; zval *zfilter; zval *zoptions = NULL; bson_t bfilter; bson_t boptions = BSON_INITIALIZER; (void)return_value_ptr; (void)return_value; (void)return_value_used; zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); intern = (php_phongo_query_t *)zend_object_store_get_object(getThis() TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "A|a!", &zfilter, &zoptions) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); intern->query = bson_new(); bson_init(&bfilter); zval_to_bson(zfilter, PHONGO_BSON_NONE, &bfilter, NULL TSRMLS_CC); if (zoptions) { bson_init(&boptions); zval_to_bson(zoptions, PHONGO_BSON_NONE, &boptions, NULL TSRMLS_CC); } if (!phongo_query_init(intern, &bfilter, &boptions TSRMLS_CC)) { bson_clear(&intern->query); } bson_destroy(&bfilter); bson_destroy(&boptions); }
/* {{{ proto void DOMElement::__construct(string name, [string value], [string uri]); */ PHP_METHOD(domelement, __construct) { zval *id; xmlNodePtr nodep = NULL, oldnode = NULL; dom_object *intern; char *name, *value = NULL, *uri = NULL; char *localname = NULL, *prefix = NULL; int errorcode = 0, uri_len = 0; int name_len, value_len = 0, name_valid; xmlNsPtr nsptr = NULL; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, dom_domexception_class_entry, &error_handling TSRMLS_CC); if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os|s!s", &id, dom_element_class_entry, &name, &name_len, &value, &value_len, &uri, &uri_len) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); name_valid = xmlValidateName((xmlChar *) name, 0); if (name_valid != 0) { php_dom_throw_error(INVALID_CHARACTER_ERR, 1 TSRMLS_CC); RETURN_FALSE; } /* Namespace logic is separate and only when uri passed in to insure no BC breakage */ if (uri_len > 0) { errorcode = dom_check_qname(name, &localname, &prefix, uri_len, name_len); if (errorcode == 0) { nodep = xmlNewNode (NULL, (xmlChar *)localname); if (nodep != NULL && uri != NULL) { nsptr = dom_get_ns(nodep, uri, &errorcode, prefix); xmlSetNs(nodep, nsptr); } } xmlFree(localname); if (prefix != NULL) { xmlFree(prefix); } if (errorcode != 0) { if (nodep != NULL) { xmlFreeNode(nodep); } php_dom_throw_error(errorcode, 1 TSRMLS_CC); RETURN_FALSE; } } else { /* If you don't pass a namespace uri, then you can't set a prefix */ localname = xmlSplitQName2((xmlChar *)name, (xmlChar **) &prefix); if (prefix != NULL) { xmlFree(localname); xmlFree(prefix); php_dom_throw_error(NAMESPACE_ERR, 1 TSRMLS_CC); RETURN_FALSE; } nodep = xmlNewNode(NULL, (xmlChar *) name); } if (!nodep) { php_dom_throw_error(INVALID_STATE_ERR, 1 TSRMLS_CC); RETURN_FALSE; } if (value_len > 0) { xmlNodeSetContentLen(nodep, (xmlChar *) value, value_len); } intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC); if (intern != NULL) { oldnode = dom_object_get_node(intern); if (oldnode != NULL) { php_libxml_node_free_resource(oldnode TSRMLS_CC); } php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC); } }
/* ArchiveWriter::__construct {{{ * */ ZEND_METHOD(ArchiveWriter, __construct) { archive_file_t *arch = NULL; int resource_id; zval *this = getThis(); const char *error_string = NULL; char *filename; long error_num, filename_len, result, format=0, compression=0; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ll", &filename, &filename_len, &format, &compression) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } #if PHP_API_VERSION < 20100412 if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } #endif if (php_check_open_basedir(filename TSRMLS_CC)) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } arch = (archive_file_t *) emalloc(sizeof(archive_file_t)); arch->stream = NULL; ALLOC_HASHTABLE(arch->entries); zend_hash_init(arch->entries, 10, NULL, _archive_entries_hash_dtor, 0); arch->mode = PHP_ARCHIVE_WRITE_MODE; arch->buf = emalloc(PHP_ARCHIVE_BUF_LEN + 1); arch->filename = estrndup(filename, filename_len); arch->arch = archive_write_new(); switch (compression) { case PHP_ARCHIVE_COMPRESSION_GZIP: if (archive_write_add_filter_gzip(arch->arch) != ARCHIVE_OK) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Gzip compression is not supported in this build"); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } break; case PHP_ARCHIVE_COMPRESSION_BZIP2: if (archive_write_add_filter_bzip2(arch->arch) != ARCHIVE_OK) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bzip2 compression is not supported in this build"); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } break; case 0: /* default value */ case PHP_ARCHIVE_COMPRESSION_NONE: /* always supported */ break; default: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported compression type %ld", compression); zend_restore_error_handling(&error_handling TSRMLS_CC); return; break; } switch (format) { case 0: /* default value */ case PHP_ARCHIVE_FORMAT_TAR: case PHP_ARCHIVE_FORMAT_PAX_RESTRICTED: archive_write_set_format_pax_restricted(arch->arch); break; case PHP_ARCHIVE_FORMAT_PAX: archive_write_set_format_pax(arch->arch); break; case PHP_ARCHIVE_FORMAT_CPIO: archive_write_set_format_cpio(arch->arch); break; case PHP_ARCHIVE_FORMAT_SHAR: archive_write_set_format_shar(arch->arch); break; case PHP_ARCHIVE_FORMAT_USTAR: archive_write_set_format_ustar(arch->arch); break; default: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported archive format: %ld", format); zend_restore_error_handling(&error_handling TSRMLS_CC); return; break; } archive_write_set_bytes_per_block(arch->arch, DEFAULT_BYTES_PER_BLOCK); result = archive_write_open(arch->arch, arch, _archive_open_clbk, _archive_write_clbk, _archive_close_clbk); /* do not pad the last block */ archive_write_set_bytes_in_last_block(arch->arch, 1); if (result) { error_num = archive_errno(arch->arch); error_string = archive_error_string(arch->arch); efree(arch->filename); efree(arch->buf); efree(arch); if (error_num && error_string) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to open file %s for writing: error #%ld, %s", filename, error_num, error_string); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to open file %s for writing: unknown error %ld", filename, result); } zend_restore_error_handling(&error_handling TSRMLS_CC); return; } resource_id = zend_list_insert(arch,le_archive); add_property_resource(this, "fd", resource_id); zend_restore_error_handling(&error_handling TSRMLS_CC); return; }
/* ArchiveWriter::finish {{{ * */ ZEND_METHOD(ArchiveWriter, finish) { zval *this = getThis(); int resource_id; HashPosition pos; archive_file_t *arch; archive_entry_t **entry; int result, error_num; const char *error_string; mode_t mode; php_stream *stream; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC); if (!_archive_get_fd(this, &arch TSRMLS_CC)) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if (zend_hash_sort(arch->entries, zend_qsort, _archive_pathname_compare, 0 TSRMLS_CC) == FAILURE) { RETURN_FALSE; } zend_hash_internal_pointer_reset_ex(arch->entries, &pos); while (zend_hash_get_current_data_ex(arch->entries, (void **)&entry, &pos) == SUCCESS) { mode = archive_entry_mode((*entry)->entry); if (S_ISREG(mode) && archive_entry_size((*entry)->entry) > 0) { if ((stream = php_stream_open_wrapper_ex((*entry)->filename, "r", ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, NULL))) { char buf[PHP_ARCHIVE_BUF_LEN]; int header_written=0; int read_bytes; while ((read_bytes = php_stream_read(stream, buf, PHP_ARCHIVE_BUF_LEN))) { if (!header_written) { /* write header only after the first successful read */ result = archive_write_header(arch->arch, (*entry)->entry); if (result == ARCHIVE_FATAL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write entry header for file %s: fatal error", (*entry)->filename); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } header_written = 1; } result = archive_write_data(arch->arch, buf, read_bytes); if (result <= 0) { error_num = archive_errno(arch->arch); error_string = archive_error_string(arch->arch); if (error_num && error_string) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write file %s to archive: error #%d, %s", (*entry)->filename, error_num, error_string); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write file %s: unknown error %d", (*entry)->filename, result); } php_stream_close(stream); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } } php_stream_close(stream); } } else { result = archive_write_header(arch->arch, (*entry)->entry); if (result == ARCHIVE_FATAL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write entry header for file %s: fatal error", (*entry)->filename); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } } zend_hash_move_forward_ex(arch->entries, &pos); } if ((resource_id = _archive_get_rsrc_id(this TSRMLS_CC))) { add_property_resource(this, "fd", 0); zend_list_delete(resource_id); zend_restore_error_handling(&error_handling TSRMLS_CC); RETURN_TRUE; } php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to finish writing of archive file"); zend_restore_error_handling(&error_handling TSRMLS_CC); }
/* ArchiveWriter::addEntry {{{ * */ ZEND_METHOD(ArchiveWriter, addEntry) { zval *this = getThis(); zval *entry_obj; archive_file_t *arch; archive_entry_t *entry, *entry_copy; char *pathname; int pathname_len; const struct stat *stat_sb; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &entry_obj) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if (!_archive_get_fd(this, &arch TSRMLS_CC)) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if (!instanceof_function(Z_OBJCE_P(entry_obj), ce_ArchiveEntry TSRMLS_CC)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "An instance of ArchiveEntry is required"); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if (!_archive_get_entry_struct(entry_obj, &entry TSRMLS_CC)) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } pathname = entry->filename; pathname_len = strlen(pathname); _archive_normalize_path(&pathname, &pathname_len); if (pathname_len == 0 || pathname[0] == '\0') { /* user is probably trying to add "./", "/", ".." or ".", ignoring it silently */ zend_restore_error_handling(&error_handling TSRMLS_CC); RETURN_TRUE; } /* copy entry.. */ entry_copy = emalloc(sizeof(archive_entry_t)); memcpy(entry_copy, entry, sizeof(archive_entry_t)); entry_copy->entry = archive_entry_new(); entry_copy->filename = estrdup(entry->filename); entry_copy->data = NULL; entry_copy->data_len = 0; archive_entry_copy_pathname(entry_copy->entry, pathname); stat_sb = archive_entry_stat(entry->entry); archive_entry_copy_stat(entry_copy->entry, stat_sb); /* ..and add it to the hash */ zend_hash_update(arch->entries, pathname, pathname_len + 1, &entry_copy, sizeof(archive_entry_t), NULL); zend_restore_error_handling(&error_handling TSRMLS_CC); RETURN_TRUE; }
void sapnwrfc_throw_connection_exception(RFC_ERROR_INFO error_info, char *msg, ...) { va_list args; zend_string *message; zval info; zval ex; va_start(args, msg); message = vstrpprintf(0, msg, args); va_end(args); array_init(&info); zend_replace_error_handling(EH_THROW, sapnwrfc_connection_exception_ce, NULL); object_init_ex(&ex, sapnwrfc_connection_exception_ce); zend_update_property_string(sapnwrfc_connection_exception_ce, &ex, "message", sizeof("message") - 1, ZSTR_VAL(message)); zend_update_property_long(sapnwrfc_connection_exception_ce, &ex, "code", sizeof("code") - 1, error_info.code); // populate errorInfo array add_assoc_long(&info, "code", error_info.code); add_assoc_str(&info, "key", sapuc_to_zend_string(error_info.key)); add_assoc_str(&info, "message", sapuc_to_zend_string(error_info.message)); switch(error_info.group) { case LOGON_FAILURE: // Error message raised when logon fails case COMMUNICATION_FAILURE: // Problems with the network connection (or backend broke down and killed the connection) case EXTERNAL_RUNTIME_FAILURE: // Problems in the RFC runtime of the external program (i.e "this" library) // no additional properties, just the generic one's from above break; case ABAP_APPLICATION_FAILURE: // ABAP Exception raised in ABAP function modules case ABAP_RUNTIME_FAILURE: // ABAP Message raised in ABAP function modules or in ABAP runtime of the backend (e.g Kernel) case EXTERNAL_APPLICATION_FAILURE: // Problems in the external program (e.g in the external server implementation) case EXTERNAL_AUTHORIZATION_FAILURE: // Problems raised in the authorization check handler provided by the external server implementation add_assoc_str(&info, "abapMsgClass", sapuc_to_zend_string(error_info.abapMsgClass)); add_assoc_str(&info, "abapMsgType", sapuc_to_zend_string(error_info.abapMsgType)); add_assoc_str(&info, "abapMsgNumber", sapuc_to_zend_string(error_info.abapMsgNumber)); add_assoc_str(&info, "abapMsgV1", sapuc_to_zend_string(error_info.abapMsgV1)); add_assoc_str(&info, "abapMsgV2", sapuc_to_zend_string(error_info.abapMsgV2)); add_assoc_str(&info, "abapMsgV3", sapuc_to_zend_string(error_info.abapMsgV3)); add_assoc_str(&info, "abapMsgV4", sapuc_to_zend_string(error_info.abapMsgV4)); break; case RFC_OK: zend_error(E_ERROR, "Internal error: exception handler called for RFC_OK"); zend_replace_error_handling(EH_NORMAL, NULL, NULL); zend_string_release(message); return; default: zend_error(E_ERROR, "Internal error: unknown error group"); zend_replace_error_handling(EH_NORMAL, NULL, NULL); zend_string_release(message); return; } zend_update_property(sapnwrfc_connection_exception_ce, &ex, "errorInfo", sizeof("errorInfo") - 1, &info); zval_ptr_dtor(&info); zend_string_release(message); zend_throw_exception_object(&ex); zend_replace_error_handling(EH_NORMAL, NULL, NULL); }
/* ArchiveReader::getNextEntry {{{ * */ ZEND_METHOD(ArchiveReader, getNextEntry) { zval *this = getThis(); archive_file_t *arch; int result, error_num, resource_id; const char *error_string; zend_bool fetch_entry_data = 0; archive_entry_t *entry; struct archive_entry *current_entry; size_t len; off_t offset; char *buf; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &fetch_entry_data) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if (!_archive_get_fd(this, &arch TSRMLS_CC)) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if (arch->struct_state == ARCHIVE_OK) { result = archive_read_next_header(arch->arch, ¤t_entry); arch->struct_state = result; entry = (archive_entry_t *) emalloc(sizeof(archive_entry_t)); entry->entry = current_entry; entry->data = NULL; entry->filename = NULL; entry->resolved_filename = NULL; entry->data_len = 0; arch->current_entry = entry; } else { zend_restore_error_handling(&error_handling TSRMLS_CC); RETURN_FALSE; } if (result && result != ARCHIVE_EOF) { arch->current_entry = NULL; error_num = archive_errno(arch->arch); error_string = archive_error_string(arch->arch); efree(entry); if (error_num && error_string) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read file %s: error #%d, %s", arch->filename, error_num, error_string); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read file %s: unknown error %d", arch->filename, result); } zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if (result == ARCHIVE_EOF) { arch->current_entry = NULL; efree(entry); zend_restore_error_handling(&error_handling TSRMLS_CC); RETURN_FALSE; } object_init_ex(return_value, ce_ArchiveEntry); if (fetch_entry_data) { while ((result = archive_read_data_block(arch->arch, (const void **)&buf, &len, &offset)) == ARCHIVE_OK) { entry->data = erealloc(entry->data, entry->data_len + len + 1); memcpy(entry->data + entry->data_len, buf, len); entry->data_len += len; } if (result && result != ARCHIVE_EOF) { error_num = archive_errno(arch->arch); error_string = archive_error_string(arch->arch); efree(entry); if (error_num && error_string) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read file %s: error #%d, %s", arch->filename, error_num, error_string); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to read file %s: unknown error %d", arch->filename, result); } zend_restore_error_handling(&error_handling TSRMLS_CC); return; } } if (entry->entry) { resource_id = zend_list_insert(entry,le_archive_entry); add_property_resource(return_value, "entry", resource_id); } zend_restore_error_handling(&error_handling TSRMLS_CC); }
/* ArchiveReader::__construct {{{ * */ ZEND_METHOD(ArchiveReader, __construct) { archive_file_t *arch = NULL; int resource_id; zval *this = getThis(); const char *error_string = NULL; char *filename; long error_num, filename_len, result, format = 0, compression = 0, block_size = 0; zend_error_handling error_handling; zend_replace_error_handling(EH_THROW, ce_ArchiveException, &error_handling TSRMLS_CC); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lll", &filename, &filename_len, &format, &compression, &block_size) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } #if PHP_API_VERSION < 20100412 if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } #endif if (php_check_open_basedir(filename TSRMLS_CC)) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } if(block_size <= 0){ block_size = PHP_ARCHIVE_BUF_LEN; } arch = (archive_file_t *) emalloc(sizeof(archive_file_t)); arch->stream = NULL; arch->current_entry = NULL; arch->entries = NULL; arch->struct_state = ARCHIVE_OK; arch->block_size = block_size; arch->mode = PHP_ARCHIVE_READ_MODE; arch->buf = emalloc(arch->block_size + 1); arch->filename = estrndup(filename, filename_len); arch->arch = archive_read_new(); archive_read_support_filter_all(arch->arch); switch(format){ case PHP_ARCHIVE_FORMAT_TAR: archive_read_support_format_tar(arch->arch); break; case PHP_ARCHIVE_FORMAT_CPIO: archive_read_support_format_cpio(arch->arch); break; default: archive_read_support_format_all(arch->arch); break; } switch(compression){ case PHP_ARCHIVE_COMPRESSION_NONE: break; case PHP_ARCHIVE_COMPRESSION_GZIP: if(archive_read_support_filter_gzip(arch->arch) != ARCHIVE_OK){ efree(arch->filename); efree(arch->buf); efree(arch); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Gzip compression support is not available in this build "); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } break; case PHP_ARCHIVE_COMPRESSION_BZIP2: if(archive_read_support_filter_gzip(arch->arch) != ARCHIVE_OK){ efree(arch->filename); efree(arch->buf); efree(arch); php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bzip2 compression support is not available in this build "); zend_restore_error_handling(&error_handling TSRMLS_CC); return; } default: archive_read_support_filter_all(arch->arch); break; } result = archive_read_open(arch->arch, arch, _archive_open_clbk, _archive_read_clbk, _archive_close_clbk); if (result) { error_num = archive_errno(arch->arch); error_string = archive_error_string(arch->arch); if (arch->stream) { php_stream_close(arch->stream); } if (error_num && error_string) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to open file %s for reading: error #%d, %s", filename, error_num, error_string); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to open file %s for reading: unknown error %d", filename, result); } zend_restore_error_handling(&error_handling TSRMLS_CC); archive_read_close(arch->arch); archive_read_free(arch->arch); efree(arch->filename); efree(arch->buf); efree(arch); return; } resource_id = zend_list_insert(arch,le_archive); add_property_resource(this, "fd", resource_id); zend_restore_error_handling(&error_handling TSRMLS_CC); return; }
/* {{{ proto void MongoDB\Driver\WriteConcern::__construct(integer|string $w[, integer $wtimeout[, boolean $journal]]) Constructs a new WriteConcern */ static PHP_METHOD(WriteConcern, __construct) { php_phongo_writeconcern_t *intern; zend_error_handling error_handling; zval *w, *journal; phongo_long wtimeout = 0; SUPPRESS_UNUSED_WARNING(return_value) SUPPRESS_UNUSED_WARNING(return_value_ptr) SUPPRESS_UNUSED_WARNING(return_value_used) zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC); intern = Z_WRITECONCERN_OBJ_P(getThis()); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|lz", &w, &wtimeout, &journal) == FAILURE) { zend_restore_error_handling(&error_handling TSRMLS_CC); return; } zend_restore_error_handling(&error_handling TSRMLS_CC); intern->write_concern = mongoc_write_concern_new(); if (Z_TYPE_P(w) == IS_LONG) { if (Z_LVAL_P(w) < -3) { phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT TSRMLS_CC, "Expected w to be >= -3, %ld given", Z_LVAL_P(w)); return; } mongoc_write_concern_set_w(intern->write_concern, Z_LVAL_P(w)); } else if (Z_TYPE_P(w) == IS_STRING) { if (strcmp(Z_STRVAL_P(w), PHONGO_WRITE_CONCERN_W_MAJORITY) == 0) { mongoc_write_concern_set_w(intern->write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY); } else { mongoc_write_concern_set_wtag(intern->write_concern, Z_STRVAL_P(w)); } } else { phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT TSRMLS_CC, "Expected w to be integer or string, %s given", zend_get_type_by_const(Z_TYPE_P(w))); return; } switch(ZEND_NUM_ARGS()) { case 3: if (Z_TYPE_P(journal) != IS_NULL) { #ifdef ZEND_ENGINE_3 mongoc_write_concern_set_journal(intern->write_concern, zend_is_true(journal)); #else mongoc_write_concern_set_journal(intern->write_concern, Z_BVAL_P(journal)); #endif } /* fallthrough */ case 2: if (wtimeout < 0) { phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT TSRMLS_CC, "Expected wtimeout to be >= 0, %" PHONGO_LONG_FORMAT " given", wtimeout); return; } if (wtimeout > INT32_MAX) { phongo_throw_exception(PHONGO_ERROR_INVALID_ARGUMENT TSRMLS_CC, "Expected wtimeout to be <= %" PRId32 ", %" PHONGO_LONG_FORMAT " given", INT32_MAX, wtimeout); return; } mongoc_write_concern_set_wtimeout(intern->write_concern, wtimeout); } } /* }}} */
int php_imagick_read_image_using_php_streams(php_imagick_object *intern, int type, char *filename, int filename_len TSRMLS_DC) { php_stream *stream; MagickBooleanType status; FILE *fp; #if ZEND_MODULE_API_NO > 20060613 zend_error_handling error_handling; #endif #if ZEND_MODULE_API_NO > 20060613 zend_replace_error_handling(EH_THROW, php_imagick_exception_class_entry, &error_handling TSRMLS_CC); #else php_set_error_handling(EH_THROW, php_imagick_exception_class_entry TSRMLS_CC); #endif stream = php_stream_open_wrapper(filename, "rb", (ENFORCE_SAFE_MODE|IGNORE_PATH) & ~REPORT_ERRORS, NULL); if (!stream) { goto return_error; } if (php_stream_can_cast(stream, PHP_STREAM_AS_STDIO|PHP_STREAM_CAST_INTERNAL) == FAILURE) { goto return_error; } if (php_stream_cast(stream, PHP_STREAM_AS_STDIO|PHP_STREAM_CAST_INTERNAL, (void*)&fp, 0) == FAILURE) { goto return_error; } #if ZEND_MODULE_API_NO > 20060613 zend_restore_error_handling(&error_handling TSRMLS_CC); #else php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); #endif if (type == 1) { status = MagickReadImageFile(intern->magick_wand, fp); } else { status = MagickPingImageFile(intern->magick_wand, fp); } if (status == MagickFalse) { php_stream_close(stream); return IMAGICK_READ_WRITE_UNDERLYING_LIBRARY; } if (php_stream_is(stream, PHP_STREAM_IS_STDIO)) { char *absolute = expand_filepath(filename, NULL TSRMLS_CC); MagickSetImageFilename(intern->magick_wand, absolute); efree(absolute); } else { /* Set to empty filename, otherwise it will point to MAGICK_TEMP/magick-XXXXX */ MagickSetImageFilename(intern->magick_wand, ""); } php_stream_close(stream); if (status == MagickFalse) { return IMAGICK_READ_WRITE_UNDERLYING_LIBRARY; } IMAGICK_CORRECT_ITERATOR_POSITION(intern); return IMAGICK_READ_WRITE_NO_ERROR; return_error: #if ZEND_MODULE_API_NO > 20060613 zend_restore_error_handling(&error_handling TSRMLS_CC); #else php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); #endif if (stream) php_stream_close(stream); return IMAGICK_READ_WRITE_UNDERLYING_LIBRARY; }