static void _php_finfo_get_type(INTERNAL_FUNCTION_PARAMETERS, int mode, int mimetype_emu) /* {{{ */ { zend_long options = 0; char *ret_val = NULL, *buffer = NULL; size_t buffer_len; php_fileinfo *finfo = NULL; zval *zfinfo, *zcontext = NULL; zval *what; char mime_directory[] = "directory"; struct magic_set *magic = NULL; FILEINFO_DECLARE_INIT_OBJECT(object) if (mimetype_emu) { /* mime_content_type(..) emulation */ if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &what) == FAILURE) { return; } switch (Z_TYPE_P(what)) { case IS_STRING: buffer = Z_STRVAL_P(what); buffer_len = Z_STRLEN_P(what); mode = FILEINFO_MODE_FILE; break; case IS_RESOURCE: mode = FILEINFO_MODE_STREAM; break; default: php_error_docref(NULL, E_WARNING, "Can only process string or stream arguments"); RETURN_FALSE; } magic = magic_open(MAGIC_MIME_TYPE); if (magic_load(magic, NULL) == -1) { php_error_docref(NULL, E_WARNING, "Failed to load magic database."); goto common; } } else if (object) { if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|lr", &buffer, &buffer_len, &options, &zcontext) == FAILURE) { RETURN_FALSE; } FILEINFO_FROM_OBJECT(finfo, object); magic = finfo->magic; } else { if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|lr", &zfinfo, &buffer, &buffer_len, &options, &zcontext) == FAILURE) { RETURN_FALSE; } if ((finfo = (php_fileinfo *)zend_fetch_resource(Z_RES_P(zfinfo), "file_info", le_fileinfo)) == NULL) { RETURN_FALSE; } magic = finfo->magic; } /* Set options for the current file/buffer. */ if (options) { FINFO_SET_OPTION(magic, options) } switch (mode) { case FILEINFO_MODE_BUFFER: { ret_val = (char *) magic_buffer(magic, buffer, buffer_len); break; } case FILEINFO_MODE_STREAM: { php_stream *stream; zend_off_t streampos; php_stream_from_zval_no_verify(stream, what); if (!stream) { goto common; } streampos = php_stream_tell(stream); /* remember stream position for restoration */ php_stream_seek(stream, 0, SEEK_SET); ret_val = (char *) magic_stream(magic, stream); php_stream_seek(stream, streampos, SEEK_SET); break; } case FILEINFO_MODE_FILE: { /* determine if the file is a local file or remote URL */ const char *tmp2; php_stream_wrapper *wrap; php_stream_statbuf ssb; if (buffer == NULL || !*buffer) { php_error_docref(NULL, E_WARNING, "Empty filename or path"); RETVAL_FALSE; goto clean; } wrap = php_stream_locate_url_wrapper(buffer, &tmp2, 0); if (wrap) { php_stream *stream; php_stream_context *context = php_stream_context_from_zval(zcontext, 0); #ifdef PHP_WIN32 if (php_stream_stat_path_ex(buffer, 0, &ssb, context) == SUCCESS) { if (ssb.sb.st_mode & S_IFDIR) { ret_val = mime_directory; goto common; } } #endif #if PHP_API_VERSION < 20100412 stream = php_stream_open_wrapper_ex(buffer, "rb", ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, context); #else stream = php_stream_open_wrapper_ex(buffer, "rb", REPORT_ERRORS, NULL, context); #endif if (!stream) { RETVAL_FALSE; goto clean; } if (php_stream_stat(stream, &ssb) == SUCCESS) { if (ssb.sb.st_mode & S_IFDIR) { ret_val = mime_directory; } else { ret_val = (char *)magic_stream(magic, stream); } } php_stream_close(stream); } break; } default: php_error_docref(NULL, E_WARNING, "Can only process string or stream arguments"); } common: if (ret_val) { RETVAL_STRING(ret_val); } else { php_error_docref(NULL, E_WARNING, "Failed identify data %d:%s", magic_errno(magic), magic_error(magic)); RETVAL_FALSE; } clean: if (mimetype_emu) { magic_close(magic); } /* Restore options */ if (options) { FINFO_SET_OPTION(magic, finfo->options) } return; }
/* {{{ char *http_etag(void *, size_t, http_send_mode) */ PHP_HTTP_API char *_http_etag(const void *data_ptr, size_t data_len, http_send_mode data_mode TSRMLS_DC) { void *ctx = http_etag_init(); if (data_mode == SEND_DATA) { http_etag_update(ctx, data_ptr, data_len); } else { STATUS ss = FAILURE; php_stream_statbuf ssb; if (data_mode == SEND_RSRC) { ss = php_stream_stat((php_stream *) data_ptr, &ssb); } else { ss = php_stream_stat_path((char *) data_ptr, &ssb); } if (SUCCESS != ss) { efree(ctx); return NULL; } else { size_t ssb_len; char ssb_buf[128]; ssb_len = snprintf(ssb_buf, sizeof(ssb_buf), "%ld=%ld=%ld", (long) ssb.sb.st_mtime, (long) ssb.sb.st_ino, (long) ssb.sb.st_size); http_etag_update(ctx, ssb_buf, ssb_len); } } return http_etag_finish(ctx); }
/* {{{ time_t http_last_modified(void *, http_send_mode) */ PHP_HTTP_API time_t _http_last_modified(const void *data_ptr, http_send_mode data_mode TSRMLS_DC) { php_stream_statbuf ssb; switch (data_mode) { case SEND_DATA: return HTTP_G->request.time; case SEND_RSRC: return php_stream_stat((php_stream *) data_ptr, &ssb) ? 0 : ssb.sb.st_mtime; default: return php_stream_stat_path((char *) data_ptr, &ssb) ? 0 : ssb.sb.st_mtime; } }
static int odbc_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, enum pdo_param_event event_type) { pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data; RETCODE rc; SWORD sqltype = 0, ctype = 0, scale = 0, nullable = 0; SQLULEN precision = 0; pdo_odbc_param *P; zval *parameter; /* we're only interested in parameters for prepared SQL right now */ if (param->is_param) { 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: { /* figure out what we're doing */ switch (PDO_PARAM_TYPE(param->param_type)) { case PDO_PARAM_LOB: break; case PDO_PARAM_STMT: return 0; default: break; } rc = SQLDescribeParam(S->stmt, (SQLUSMALLINT) param->paramno+1, &sqltype, &precision, &scale, &nullable); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { /* MS Access, for instance, doesn't support SQLDescribeParam, * so we need to guess */ sqltype = PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB ? SQL_LONGVARBINARY : SQL_LONGVARCHAR; precision = 4000; scale = 5; nullable = 1; if (param->max_value_len > 0) { precision = param->max_value_len; } } if (sqltype == SQL_BINARY || sqltype == SQL_VARBINARY || sqltype == SQL_LONGVARBINARY) { ctype = SQL_C_BINARY; } else { ctype = SQL_C_CHAR; } P = emalloc(sizeof(*P)); param->driver_data = P; P->len = 0; /* is re-populated each EXEC_PRE */ P->outbuf = NULL; P->is_unicode = pdo_odbc_sqltype_is_unicode(S, sqltype); if (P->is_unicode) { /* avoid driver auto-translation: we'll do it ourselves */ ctype = SQL_C_BINARY; } if ((param->param_type & PDO_PARAM_INPUT_OUTPUT) == PDO_PARAM_INPUT_OUTPUT) { P->paramtype = SQL_PARAM_INPUT_OUTPUT; } else if (param->max_value_len <= 0) { P->paramtype = SQL_PARAM_INPUT; } else { P->paramtype = SQL_PARAM_OUTPUT; } if (P->paramtype != SQL_PARAM_INPUT) { if (PDO_PARAM_TYPE(param->param_type) != PDO_PARAM_NULL) { /* need an explicit buffer to hold result */ P->len = param->max_value_len > 0 ? param->max_value_len : precision; if (P->is_unicode) { P->len *= 2; } P->outbuf = emalloc(P->len + (P->is_unicode ? 2:1)); } } if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB && P->paramtype != SQL_PARAM_INPUT) { pdo_odbc_stmt_error("Can't bind a lob for output"); return 0; } rc = SQLBindParameter(S->stmt, (SQLUSMALLINT) param->paramno+1, P->paramtype, ctype, sqltype, precision, scale, P->paramtype == SQL_PARAM_INPUT ? (SQLPOINTER)param : P->outbuf, P->len, &P->len ); if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) { return 1; } pdo_odbc_stmt_error("SQLBindParameter"); return 0; } case PDO_PARAM_EVT_EXEC_PRE: P = param->driver_data; if (!Z_ISREF(param->parameter)) { parameter = ¶m->parameter; } else { parameter = Z_REFVAL(param->parameter); } if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) { if (Z_TYPE_P(parameter) == IS_RESOURCE) { php_stream *stm; php_stream_statbuf sb; php_stream_from_zval_no_verify(stm, parameter); if (!stm) { return 0; } if (0 == php_stream_stat(stm, &sb)) { if (P->outbuf) { int len, amount; char *ptr = P->outbuf; char *end = P->outbuf + P->len; P->len = 0; do { amount = end - ptr; if (amount == 0) { break; } if (amount > 8192) amount = 8192; len = php_stream_read(stm, ptr, amount); if (len == 0) { break; } ptr += len; P->len += len; } while (1); } else { P->len = SQL_LEN_DATA_AT_EXEC(sb.sb.st_size); } } else { if (P->outbuf) { P->len = 0; } else { P->len = SQL_LEN_DATA_AT_EXEC(0); } } } else { convert_to_string(parameter); if (P->outbuf) { P->len = Z_STRLEN_P(parameter); memcpy(P->outbuf, Z_STRVAL_P(parameter), P->len); } else { P->len = SQL_LEN_DATA_AT_EXEC(Z_STRLEN_P(parameter)); } } } else if (Z_TYPE_P(parameter) == IS_NULL || PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL) { P->len = SQL_NULL_DATA; } else { convert_to_string(parameter); if (P->outbuf) { zend_ulong ulen; switch (pdo_odbc_utf82ucs2(stmt, P->is_unicode, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), &ulen)) { case PDO_ODBC_CONV_FAIL: case PDO_ODBC_CONV_NOT_REQUIRED: P->len = Z_STRLEN_P(parameter); memcpy(P->outbuf, Z_STRVAL_P(parameter), P->len); break; case PDO_ODBC_CONV_OK: P->len = ulen; memcpy(P->outbuf, S->convbuf, P->len); break; } } else { P->len = SQL_LEN_DATA_AT_EXEC(Z_STRLEN_P(parameter)); } } return 1; case PDO_PARAM_EVT_EXEC_POST: P = param->driver_data; if (P->outbuf) { zend_ulong ulen; char *srcbuf; zend_ulong srclen = 0; if (Z_ISREF(param->parameter)) { parameter = Z_REFVAL(param->parameter); } else { parameter = ¶m->parameter; } zval_ptr_dtor(parameter); ZVAL_NULL(parameter); switch (P->len) { case SQL_NULL_DATA: break; default: switch (pdo_odbc_ucs22utf8(stmt, P->is_unicode, P->outbuf, P->len, &ulen)) { case PDO_ODBC_CONV_FAIL: /* something fishy, but allow it to come back as binary */ case PDO_ODBC_CONV_NOT_REQUIRED: srcbuf = P->outbuf; srclen = P->len; break; case PDO_ODBC_CONV_OK: srcbuf = S->convbuf; srclen = ulen; break; } ZVAL_NEW_STR(parameter, zend_string_alloc(srclen, 0)); memcpy(Z_STRVAL_P(parameter), srcbuf, srclen); Z_STRVAL_P(parameter)[Z_STRLEN_P(parameter)] = '\0'; } } return 1; } } return 1; }
static zend_bool php_cairo_create_ft_font_face(pecl_ft_container *ft_container, cairo_ft_font_face_object *font_face_object, php_stream *stream, zend_bool owned_stream, int load_flags, zend_bool throw_exceptions TSRMLS_DC) { FT_Stream ft_stream; stream_closure *closure; php_stream_statbuf ssbuf; FT_Open_Args open_args; int error; if (php_stream_stat(stream,&ssbuf) < 0) { return 1; } ft_container->ft_face = NULL; ft_container->ft_stream = NULL; font_face_object->closure = NULL; closure = ecalloc(1, sizeof(stream_closure)); closure->stream = stream; closure->owned_stream = owned_stream; #ifdef ZTS closure->TSRMLS_C = TSRMLS_C; #endif ft_stream = pecalloc(1, sizeof(*ft_stream), TRUE); ft_stream->descriptor.pointer = (void *)closure; ft_stream->pos = php_stream_tell(stream); ft_stream->size = ssbuf.sb.st_size; ft_stream->read = php_cairo_ft_read_func; open_args.flags = FT_OPEN_STREAM; open_args.stream = ft_stream; error = FT_Open_Face(ft_container->ft_lib, &open_args, 0, &ft_container->ft_face); if (error) { if (owned_stream) { php_stream_close(stream); } efree(closure); pefree(ft_stream, TRUE); return error; } font_face_object->closure = closure; ft_container->ft_stream = ft_stream; font_face_object->font_face = (cairo_font_face_t *)cairo_ft_font_face_create_for_ft_face(ft_container->ft_face, (int)load_flags); /* Set Cairo to automatically destroy the FT_Face when the cairo_font_face_t is destroyed */ error = cairo_font_face_set_user_data ( font_face_object->font_face, &font_face_object->key, ft_container, (cairo_destroy_func_t) cairo_user_data_callback_ft_free); if (error) { cairo_font_face_destroy (font_face_object->font_face); FT_Done_Face(ft_container->ft_face); pefree(ft_stream, TRUE); return error; } return 0; }