hholzgra Mon Oct 21 15:55:29 2002 EDT
Modified files:
/php4/ext/fdf config.m4 fdf.c php_fdf.h
Log:
@ updated FDF extension to work with current Adodeb fdftk 5.0 (hartmut)
reworked some existing stuff
added some functions suporting stuff that have been added since fdftk 2.0
emulating read from/save to strings by transparently using temp. files
(activeX version of fdftk has this, but not plain C version :( )
Index: php4/ext/fdf/config.m4
diff -u php4/ext/fdf/config.m4:1.18 php4/ext/fdf/config.m4:1.19
--- php4/ext/fdf/config.m4:1.18 Tue Mar 19 19:39:28 2002
+++ php4/ext/fdf/config.m4 Mon Oct 21 15:55:28 2002
@@ -1,5 +1,5 @@
dnl
-dnl $Id: config.m4,v 1.18 2002/03/20 00:39:28 sniper Exp $
+dnl $Id: config.m4,v 1.19 2002/10/21 19:55:28 hholzgra Exp $
dnl
PHP_ARG_WITH(fdftk, for FDF support,
@@ -7,32 +7,68 @@
if test "$PHP_FDFTK" != "no"; then
- for i in /usr /usr/local $PHP_FDFTK; do
- if test -r $i/include/FdfTk.h; then
- FDFTK_DIR=$i
- elif test -r $i/include/fdftk.h; then
- AC_DEFINE(HAVE_FDFTK_H_LOWER,1,[ ])
- FDFTK_DIR=$i
- fi
+ case $host_os in
+ aix*)
+ libtype=aix
+ ;;
+ solaris* )
+ libtype=solaris
+ ;;
+ linux*)
+ libtype=linux
+ ;;
+ *)
+ AC_MSG_ERROR(sorry but the fdf tookkit is available for aix, solaris
+and linux only ... $host_os ... blame adboe)
+ ;;
+ esac
+
+ if test "$PHP_FDFTK" = "yes"; then
+ PHP_FDFTK="/usr /usr/local ../FDFToolkitForUNIX
+ext/fdf/FDFToolkitForUNIX"
+ fi
+
+ for dir in $PHP_FDFTK; do
+ for subdir in include HeadersAndLibraries/headers; do
+ if test -r $dir/$subdir/FdfTk.h; then
+ FDFTK_DIR=$dir
+ FDFTK_H_DIR=$dir/$subdir
+ elif test -r $dir/$subdir/fdftk.h; then
+ AC_DEFINE(HAVE_FDFTK_H_LOWER,1,[ ])
+ FDFTK_DIR=$dir
+ FDFTK_H_DIR=$dir/$subdir
+ fi
+ done
done
if test -z "$FDFTK_DIR"; then
AC_MSG_ERROR(FdfTk.h or fdftk.h not found. Please reinstall the fdftk
distribution.)
fi
- PHP_ADD_INCLUDE($FDFTK_DIR/include)
-
+ PHP_ADD_INCLUDE($FDFTK_H_DIR)
+
FDFLIBRARY=""
- for i in fdftk FdfTk; do
- PHP_CHECK_LIBRARY($i, FDFOpen, [FDFLIBRARY=$i], [], [-L$FDFTK_DIR/lib -lm])
- done
+ for file in fdftk FdfTk; do
+ for dir in $FDFTK_DIR/lib $FDFTK_DIR/HeadersAndLibraries/$libtype/C; do
+ echo testing $dir/lib$file.so
+ if test -r $dir/lib$file.so; then
+ if test -z "$FDFLIBRARY"; then
+ PHP_CHECK_LIBRARY($file, FDFOpen, [FDFLIBRARY=$file], [], [-L$dir -lm])
+ if test "$FDFLIBRARY"; then
+ echo ok
+ FDFTK_LIB_DIR=$dir
+ fi
+ fi
+ fi
+ done
+ done
if test -z "$FDFLIBRARY"; then
- AC_MSG_ERROR(fdftk module requires >= fdftk 2.0)
+ AC_MSG_ERROR(no usable fdf library found)
fi
+
+
AC_DEFINE(HAVE_FDFLIB,1,[ ])
- PHP_ADD_LIBRARY_WITH_PATH($FDFLIBRARY, $FDFTK_DIR/lib, FDFTK_SHARED_LIBADD)
+ PHP_ADD_LIBRARY_WITH_PATH($FDFLIBRARY, $FDFTK_LIB_DIR, FDFTK_SHARED_LIBADD)
PHP_SUBST(FDFTK_SHARED_LIBADD)
PHP_NEW_EXTENSION(fdf, fdf.c, $ext_shared)
Index: php4/ext/fdf/fdf.c
diff -u php4/ext/fdf/fdf.c:1.64 php4/ext/fdf/fdf.c:1.65
--- php4/ext/fdf/fdf.c:1.64 Thu Jun 27 02:46:51 2002
+++ php4/ext/fdf/fdf.c Mon Oct 21 15:55:28 2002
@@ -17,7 +17,7 @@
+----------------------------------------------------------------------+
*/
-/* $Id: fdf.c,v 1.64 2002/06/27 06:46:51 derick Exp $ */
+/* $Id: fdf.c,v 1.65 2002/10/21 19:55:28 hholzgra Exp $ */
/* FdfTk lib 2.0 is a Complete C/C++ FDF Toolkit available from
http://beta1.adobe.com/ada/acrosdk/forms.html. */
@@ -29,6 +29,7 @@
#endif
#include "php.h"
+#include "php_open_temporary_file.h"
#if HAVE_FDFLIB
@@ -45,24 +46,41 @@
/* {{{ fdf_functions[]
*/
function_entry fdf_functions[] = {
- PHP_FE(fdf_open,
NULL)
- PHP_FE(fdf_create,
NULL)
+ PHP_FE(fdf_add_doc_javascript, NULL)
+ PHP_FE(fdf_add_template, NULL)
PHP_FE(fdf_close,
NULL)
- PHP_FE(fdf_save,
NULL)
+ PHP_FE(fdf_create,
+ NULL)
+ PHP_FE(fdf_enum_values, NULL)
+ PHP_FE(fdf_errno, NULL)
+ PHP_FE(fdf_error, NULL)
+ PHP_FE(fdf_get_ap,
+ NULL)
+ PHP_FE(fdf_get_attachment, NULL)
+ PHP_FE(fdf_get_encoding, NULL)
+ PHP_FE(fdf_get_file, NULL)
+ PHP_FE(fdf_get_flags, NULL)
+ PHP_FE(fdf_get_opt,
+ NULL)
+ PHP_FE(fdf_get_status, NULL)
PHP_FE(fdf_get_value, NULL)
- PHP_FE(fdf_set_value, NULL)
+ PHP_FE(fdf_get_version, NULL)
PHP_FE(fdf_next_field_name, NULL)
+ PHP_FE(fdf_open,
+ NULL)
+ PHP_FE(fdf_open_string, NULL)
+ PHP_FE(fdf_remove_item, NULL)
+ PHP_FE(fdf_save,
+ NULL)
+ PHP_FE(fdf_save_string, NULL)
PHP_FE(fdf_set_ap,
NULL)
- PHP_FE(fdf_set_status, NULL)
- PHP_FE(fdf_get_status, NULL)
+ PHP_FE(fdf_set_encoding, NULL)
PHP_FE(fdf_set_file, NULL)
- PHP_FE(fdf_get_file, NULL)
- PHP_FE(fdf_add_template, NULL)
PHP_FE(fdf_set_flags, NULL)
+ PHP_FE(fdf_set_javascript_action, NULL)
+ PHP_FE(fdf_set_on_import_javascript, NULL)
PHP_FE(fdf_set_opt,
NULL)
+ PHP_FE(fdf_set_status, NULL)
PHP_FE(fdf_set_submit_form_action, NULL)
- PHP_FE(fdf_set_javascript_action, NULL)
- PHP_FE(fdf_set_encoding, NULL)
+ PHP_FE(fdf_set_target_frame, NULL)
+ PHP_FE(fdf_set_value, NULL)
+ PHP_FE(fdf_set_version, NULL)
+ PHP_FE(fdf_header, NULL)
{NULL, NULL, NULL}
};
/* }}} */
@@ -73,7 +91,7 @@
fdf_functions,
PHP_MINIT(fdf),
PHP_MSHUTDOWN(fdf),
- NULL,
+ PHP_RINIT(fdf),
NULL,
PHP_MINFO(fdf),
NO_VERSION_YET,
@@ -84,6 +102,10 @@
ZEND_GET_MODULE(fdf)
#endif
+ZEND_DECLARE_MODULE_GLOBALS(fdf)
+
+#define FDF_SUCCESS do { FDF_G(error)=FDFErcOK; RETURN_TRUE;} while(0)
+#define FDF_FAILURE(err) do { FDF_G(error)=err; RETURN_FALSE;} while(0)
static void phpi_FDFClose(zend_rsrc_list_entry *rsrc TSRMLS_DC)
{
@@ -92,7 +114,6 @@
(void) FDFClose(fdf);
}
-
#define FDF_POST_CONTENT_TYPE "application/vnd.fdf"
static sapi_post_entry php_fdf_post_entry = {
@@ -110,11 +131,11 @@
le_fdf = zend_register_list_destructors_ex(phpi_FDFClose, NULL, "fdf",
module_number);
- /* add handler for Acrobat FDF form post requests */
+ /* add handler for Acrobat FDF form post requests */
sapi_register_post_entry(&php_fdf_post_entry);
- /* Constants used by fdf_set_opt() */
+ /* Constants used by fdf_set_opt() */
REGISTER_LONG_CONSTANT("FDFValue", FDFValue, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("FDFStatus", FDFStatus, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("FDFFile", FDFFile, CONST_CS | CONST_PERSISTENT);
@@ -142,6 +163,11 @@
REGISTER_LONG_CONSTANT("FDFKeystroke", FDFKeystroke, CONST_CS |
CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("FDFCalculate", FDFCalculate, CONST_CS |
CONST_PERSISTENT);
+ /* Constants used by fdf_(set|get)_ap */
+ REGISTER_LONG_CONSTANT("FDFNormalAP", 1, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("FDFRolloverAP", 2, CONST_CS | CONST_PERSISTENT);
+ REGISTER_LONG_CONSTANT("FDFDownAP", 3, CONST_CS | CONST_PERSISTENT);
+
#ifdef PHP_WIN32
return SUCCESS;
#endif
@@ -150,6 +176,13 @@
}
/* }}} */
+/* {{{ RINIT */
+PHP_RINIT_FUNCTION(fdf) {
+ FDF_G(error) = FDFErcOK;
+ return SUCCESS;
+}
+/* }}} */
+
/* {{{ PHP_MINFO_FUNCTION
*/
PHP_MINFO_FUNCTION(fdf)
@@ -196,9 +229,46 @@
err = FDFOpen(Z_STRVAL_PP(file), 0, &fdf);
if(err != FDFErcOK || !fdf) {
- php_error(E_WARNING, "%s(): Could not open fdf document: %s",
get_active_function_name(TSRMLS_C), Z_STRVAL_PP(file));
+ if(err == FDFErcOK) err= FDFErcInternalError;
+ FDF_FAILURE(err);
+ }
+
+ ZEND_REGISTER_RESOURCE(return_value, fdf, le_fdf);
+}
+/* }}} */
+
+/* {{{ proto int fdf_open_string(string fdf_data)
+ Opens a new FDF document from string */
+PHP_FUNCTION(fdf_open_string)
+{
+ char *fdf_data;
+ int fdf_data_len;
+ FDFDoc fdf;
+ FDFErc err;
+ char *temp_filename;
+ FILE *fp;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",
+ &fdf_data, &fdf_data_len)
+ == FAILURE) {
+ return;
+ }
+
+ fp = php_open_temporary_file(PG(upload_tmp_dir), "php", &temp_filename
+TSRMLS_CC);
+ if(!fp) {
RETURN_FALSE;
}
+ fwrite(fdf_data, fdf_data_len, 1, fp);
+ fclose(fp);
+
+ err = FDFOpen(temp_filename, 0, &fdf);
+ unlink(temp_filename);
+ efree(temp_filename);
+
+ if(err != FDFErcOK || !fdf) {
+ if(err == FDFErcOK) err= FDFErcInternalError;
+ FDF_FAILURE(err);
+ }
ZEND_REGISTER_RESOURCE(return_value, fdf, le_fdf);
}
@@ -218,15 +288,15 @@
err = FDFCreate(&fdf);
if(err != FDFErcOK || !fdf) {
- php_error(E_WARNING, "%s(): Error creating new fdf document!",
get_active_function_name(TSRMLS_C));
- RETURN_FALSE;
+ if(err == FDFErcOK) err= FDFErcInternalError;
+ FDF_FAILURE(err);
}
ZEND_REGISTER_RESOURCE(return_value, fdf, le_fdf);
}
/* }}} */
-/* {{{ proto bool fdf_close(int fdfdoc)
+/* {{{ proto bool fdf_close(resource fdfdoc)
Closes the FDF document */
PHP_FUNCTION(fdf_close)
{
@@ -242,70 +312,140 @@
}
/* }}} */
-/* {{{ proto string fdf_get_value(int fdfdoc, string fieldname)
+/* {{{ proto string fdf_get_value(resource fdfdoc, string fieldname [, int which])
Gets the value of a field as string */
PHP_FUNCTION(fdf_get_value)
{
- zval **fdfp, **fieldname;
- ASInt32 nr, size = 256;
- char *buffer;
+ zval *r_fdf;
+ char *fieldname;
+ int fieldname_len;
+ long which = -1;
FDFDoc fdf;
FDFErc err;
+ ASInt32 nr, size = 256;
+ char *buffer;
- if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &fdfp, &fieldname) ==
FAILURE) {
- WRONG_PARAM_COUNT;
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l",
+ &r_fdf, &fieldname,
+&fieldname_len,
+ &which)
+ == FAILURE) {
+ return;
}
- ZEND_FETCH_RESOURCE(fdf, FDFDoc *, fdfp, -1, "fdf", le_fdf);
-
- convert_to_string_ex(fieldname);
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
buffer = emalloc(size);
- err = FDFGetValue(fdf, Z_STRVAL_PP(fieldname), buffer, size-1, &nr);
+ if(which >= 0) {
+ err = FDFGetNthValue(fdf, fieldname, which, buffer, size-2, &nr);
+ } else {
+ err = FDFGetValue(fdf, fieldname, buffer, size-2, &nr);
+ }
if(err == FDFErcBufTooShort && nr > 0 ) {
- buffer = erealloc(buffer, nr+1);
- err = FDFGetValue(fdf, Z_STRVAL_PP(fieldname), buffer, nr, &nr);
- }
+ buffer = erealloc(buffer, nr+2);
+ if(which >= 0) {
+ err = FDFGetNthValue(fdf, fieldname, which, buffer, nr, &nr);
+ } else {
+ err = FDFGetValue(fdf, fieldname, buffer, nr, &nr);
+ }
+ } else if((err == FDFErcValueIsArray) && (which == -1)) {
+ if (array_init(return_value) == FAILURE) {
+ efree(buffer);
+ FDF_FAILURE(FDFErcInternalError);
+ }
+ which = 0;
+ do {
+ err = FDFGetNthValue(fdf, fieldname, which, buffer, size-2,
+&nr);
+ if(err == FDFErcBufTooShort && nr > 0 ) {
+ buffer = erealloc(buffer, nr+2);
+ err = FDFGetNthValue(fdf, fieldname, which, buffer,
+nr, &nr);
+ }
+ if (err == FDFErcOK) {
+ add_next_index_string(return_value, buffer, 1);
+ }
+ which++;
+ } while (err == FDFErcOK);
+ if(err == FDFErcNoValue) err = FDFErcOK;
+ efree(buffer);
+ buffer = NULL;
+ }
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error getting value of %s",
get_active_function_name(TSRMLS_C), Z_STRVAL_PP(fieldname));
+ if(buffer) efree(buffer);
+ FDF_FAILURE(err);
+ }
+
+ if(buffer) {
+ RETVAL_STRING(buffer, 1);
efree(buffer);
- RETURN_FALSE;
}
- RETVAL_STRING(buffer, 1);
- efree(buffer);
+ return;
}
/* }}} */
-/* {{{ proto bool fdf_set_value(int fdfdoc, string fieldname, string value, int
isname)
+/* {{{ proto bool fdf_set_value(resource fdfdoc, string fieldname, mixed value [, int
+isname])
Sets the value of a field */
PHP_FUNCTION(fdf_set_value)
{
- zval **fdfp, **fieldname, **value, **isname;
+ zval **fdfp, **fieldname, **value, **dummy;
FDFDoc fdf;
FDFErc err;
- if (ZEND_NUM_ARGS() != 4 || zend_get_parameters_ex(4, &fdfp, &fieldname,
&value, &isname) == FAILURE) {
+ switch(ZEND_NUM_ARGS()) {
+ case 3:
+ if (zend_get_parameters_ex(3, &fdfp, &fieldname, &value) == FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+ break;
+ case 4:
+ if (zend_get_parameters_ex(4, &fdfp, &fieldname, &value, &dummy) ==
+FAILURE) {
+ WRONG_PARAM_COUNT;
+ }
+ break;
+ default:
WRONG_PARAM_COUNT;
}
ZEND_FETCH_RESOURCE(fdf, FDFDoc *, fdfp, -1, "fdf", le_fdf);
convert_to_string_ex(fieldname);
- convert_to_string_ex(value);
- convert_to_long_ex(isname);
- err = FDFSetValue(fdf, Z_STRVAL_PP(fieldname), Z_STRVAL_PP(value), (ASBool)
Z_LVAL_PP(isname));
+ if (Z_TYPE_PP(value) == IS_ARRAY) {
+ ASInt32 nValues = zend_hash_num_elements(Z_ARRVAL_PP(value));
+ char **newValues = ecalloc(nValues, sizeof(char *)), **next;
+ HashPosition pos;
+ zval **tmp;
+
+ next = newValues;
+ zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(value), &pos);
+ while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(value),
+
+ (void **) &tmp,
+
+ &pos) == SUCCESS) {
+ convert_to_string_ex(tmp);
+ *next++ = estrdup(Z_STRVAL_PP(tmp));
+ zend_hash_move_forward_ex(Z_ARRVAL_PP(value), &pos);
+ }
+
+ err = FDFSetValues(fdf, Z_STRVAL_PP(fieldname), nValues, (const char
+**)newValues);
+
+
+ for(next = newValues; nValues; nValues--) {
+ efree(*next++);
+ }
+ efree(newValues);
+ } else {
+ convert_to_string_ex(value);
+
+ err = FDFSetValue(fdf, Z_STRVAL_PP(fieldname), Z_STRVAL_PP(value),
+(ASBool)0 /*dummy*/);
+ }
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting field: %s to value: %s",
get_active_function_name(TSRMLS_C), Z_STRVAL_PP(fieldname), Z_STRVAL_PP(value));
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
- RETURN_TRUE;
+ FDF_SUCCESS;
}
/* }}} */
-/* {{{ proto string fdf_next_field_name(int fdfdoc [, string fieldname])
+/* {{{ proto string fdf_next_field_name(resource fdfdoc [, string fieldname])
Gets the name of the next field name or the first field name */
PHP_FUNCTION(fdf_next_field_name)
{
@@ -337,8 +477,7 @@
if(err != FDFErcOK) {
efree(buffer);
- php_error(E_WARNING, "%s(): Error getting next fieldname!",
get_active_function_name(TSRMLS_C));
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
RETVAL_STRING(buffer, 1);
@@ -346,7 +485,7 @@
}
/* }}} */
-/* {{{ proto bool fdf_set_ap(int fdfdoc, string fieldname, int face, string filename,
int pagenr)
+/* {{{ proto bool fdf_set_ap(resource fdfdoc, string fieldname, int face, string
+filename, int pagenr)
Sets the appearence of a field */
PHP_FUNCTION(fdf_set_ap)
{
@@ -378,6 +517,7 @@
break;
default:
facenr = FDFNormalAP;
+ break;
}
err = FDFSetAP(fdf, Z_STRVAL_PP(fieldname), facenr, NULL,
Z_STRVAL_PP(filename), (ASInt32) Z_LVAL_PP(pagenr));
@@ -386,16 +526,94 @@
possible errors this function can return. Or create global error handler
function.
*/
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting appearence of field: %s",
get_active_function_name(TSRMLS_C), Z_STRVAL_PP(fieldname));
- RETURN_FALSE;
+ FDF_FAILURE(err);
+ }
+
+ FDF_SUCCESS;
+
+}
+/* }}} */
+
+/* {{{ proto bool fdf_get_ap(resource fdfdoc, string fieldname, int face, string
+filename)
+ Gets the appearance of a field and creates a PDF document out of it. */
+PHP_FUNCTION(fdf_get_ap) {
+ zval *r_fdf;
+ char *fieldname, *filename;
+ int fieldname_len, filename_len, face;
+ FDFDoc fdf;
+ FDFErc err;
+ FDFAppFace facenr;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsls",
+ &r_fdf, &fieldname,
+&fieldname_len,
+ &face, &filename,
+&filename_len)
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ switch(face) {
+ case 1:
+ facenr = FDFNormalAP;
+ break;
+ case 2:
+ facenr = FDFRolloverAP;
+ break;
+ case 3:
+ facenr = FDFDownAP;
+ break;
+ default:
+ facenr = FDFNormalAP;
+ break;
}
- RETURN_TRUE;
+ err = FDFGetAP(fdf, fieldname, facenr, filename);
+ /* This should be made more intelligent, ie. use switch() with the
+ possible errors this function can return. Or create global error handler
+function.
+ */
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+
+ FDF_SUCCESS;
+
+
}
/* }}} */
-/* {{{ proto bool fdf_set_status(int fdfdoc, string status)
+/* {{{ proto string fdf_get_encoding(resource fdf)
+ Gets FDF file encoding scheme */
+PHP_FUNCTION(fdf_get_encoding) {
+ zval *r_fdf;
+ FDFDoc fdf;
+ FDFErc err;
+ char buffer[32];
+ ASInt32 len;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r",
+ &r_fdf) == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ err = FDFGetEncoding(fdf, buffer, 32, &len);
+
+ /* This should be made more intelligent, ie. use switch() with the
+ possible errors this function can return. Or create global error handler
+function.
+ */
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+
+ FDF_G(error) = FDFErcOK;
+ RETURN_STRINGL(buffer, (size_t)len, 1);
+}
+/* }}} */
+
+/* {{{ proto bool fdf_set_status(resource fdfdoc, string status)
Sets the value of /Status key */
PHP_FUNCTION(fdf_set_status)
{
@@ -413,15 +631,14 @@
err = FDFSetStatus(fdf, Z_STRVAL_PP(status));
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting fdf document status key to:
%s", get_active_function_name(TSRMLS_C), Z_STRVAL_PP(status));
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
- RETURN_TRUE;
+ FDF_SUCCESS;
}
/* }}} */
-/* {{{ proto string fdf_get_status(int fdfdoc)
+/* {{{ proto string fdf_get_status(resource fdfdoc)
Gets the value of /Status key */
PHP_FUNCTION(fdf_get_status)
{
@@ -446,9 +663,8 @@
}
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error getting fdf document status key!",
get_active_function_name(TSRMLS_C));
efree(buf);
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
RETVAL_STRING(buf, 1);
@@ -456,33 +672,41 @@
}
/* }}} */
-/* {{{ proto bool fdf_set_file(int fdfdoc, string filename)
+/* {{{ proto bool fdf_set_file(resource fdfdoc, string filename [, string
+target_frame])
Sets the value of /F key */
PHP_FUNCTION(fdf_set_file)
{
- zval **fdfp, **filename;
+ zval *r_fdf;
+ char *filename, *target_frame= NULL;
+ int filename_len, target_frame_len;
FDFDoc fdf;
FDFErc err;
- if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &fdfp, &filename) ==
FAILURE) {
- WRONG_PARAM_COUNT;
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|s", &r_fdf,
+ &filename, &filename_len,
+ &target_frame,
+&target_frame_len)
+ == FAILURE) {
+ return;
}
- ZEND_FETCH_RESOURCE(fdf, FDFDoc *, fdfp, -1, "fdf", le_fdf);
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
- convert_to_string_ex(filename);
-
- err = FDFSetFile(fdf, Z_STRVAL_PP(filename));
+ err = FDFSetFile(fdf, filename);
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting filename key to: %s",
get_active_function_name(TSRMLS_C), Z_STRVAL_PP(filename));
- RETURN_FALSE;
+ FDF_FAILURE(err);
+ }
+ if(target_frame) {
+ err = FDFSetTargetFrame(fdf, target_frame);
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
}
- RETURN_TRUE;
+ FDF_SUCCESS;
}
/* }}} */
-/* {{{ proto string fdf_get_file(int fdfdoc)
+/* {{{ proto string fdf_get_file(resource fdfdoc)
Gets the value of /F key */
PHP_FUNCTION(fdf_get_file)
{
@@ -507,9 +731,8 @@
}
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error getting fdf document filename key!",
get_active_function_name(TSRMLS_C));
efree(buf);
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
RETVAL_STRING(buf, 1);
@@ -517,33 +740,119 @@
}
/* }}} */
-/* {{{ proto bool fdf_save(int fdfdoc, string filename)
+/* {{{ proto mixed fdf_save(resource fdfdoc [, string filename])
Writes out the FDF file */
PHP_FUNCTION(fdf_save)
{
- zval **fdfp, **filename;
+ zval *r_fdf;
+ char *filename = NULL;
+ int filename_len;
FDFDoc fdf;
FDFErc err;
- if (ZEND_NUM_ARGS() != 2 || zend_get_parameters_ex(2, &fdfp, &filename) ==
FAILURE) {
- WRONG_PARAM_COUNT;
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s", &r_fdf, &filename,
+&filename_len)
+ == FAILURE) {
+ return;
}
- ZEND_FETCH_RESOURCE(fdf, FDFDoc *, fdfp, -1, "fdf", le_fdf);
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ if(filename) {
+ err = FDFSave(fdf, filename);
+ } else {
+ FILE *fp;
+ char *temp_filename;
+
+ fp = php_open_temporary_file(PG(upload_tmp_dir), "php", &temp_filename
+TSRMLS_CC);
+ if(!fp) {
+ err = FDFErcFileSysErr;
+ } else {
+ fclose(fp);
+ err = FDFSave(fdf, temp_filename);
+
+ if(err == FDFErcOK) {
+ php_stream *stream =
+php_stream_open_wrapper(temp_filename, "rb", 0, NULL);
+ if (stream) {
+ php_stream_passthru(stream);
+ php_stream_close(stream);
+ } else {
+ err = FDFErcFileSysErr;
+ }
+ }
+ }
+ if(temp_filename) {
+ unlink(temp_filename);
+ efree(temp_filename);
+ }
+ }
- convert_to_string_ex(filename);
- err = FDFSave(fdf, Z_STRVAL_PP(filename));
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error saving fdf document into filename:
%s", get_active_function_name(TSRMLS_C), Z_STRVAL_PP(filename));
- RETURN_FALSE;
+ FDF_FAILURE(err);
+ }
+
+ FDF_SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto mixed fdf_save_string(resource fdfdoc)
+ Returns the FDF file as a string */
+PHP_FUNCTION(fdf_save_string)
+{
+ zval *r_fdf;
+ FDFDoc fdf;
+ FDFErc err;
+ FILE *fp;
+ char *temp_filename = NULL;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &r_fdf)
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ fp = php_open_temporary_file(PG(upload_tmp_dir), "php", &temp_filename
+TSRMLS_CC);
+ if(!fp) {
+ err = FDFErcFileSysErr;
+ } else {
+ fclose(fp);
+ err = FDFSave(fdf, temp_filename);
+
+ if(err == FDFErcOK) {
+ fp = fopen(temp_filename, "rb");
+ if (fp) {
+ struct stat stat;
+ char *buf;
+
+ fstat(fileno(fp), &stat);
+ buf = emalloc(stat.st_size +1);
+ fread(buf, stat.st_size, 1, fp);
+ buf[stat.st_size] = '\0';
+ fclose(fp);
+
+ unlink(temp_filename);
+ efree(temp_filename);
+ RETURN_STRINGL(buf, stat.st_size, 0);
+ } else {
+ err = FDFErcFileSysErr;
+ }
+ }
+ }
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
}
- RETURN_TRUE;
+ if(temp_filename) {
+ unlink(temp_filename);
+ efree(temp_filename);
+ }
+ return;
}
/* }}} */
-/* {{{ proto bool fdf_add_template(int fdfdoc, int newpage, string filename, string
template, int rename)
+/* {{{ proto bool fdf_add_template(resource fdfdoc, int newpage, string filename,
+string template, int rename)
Adds a template into the FDF document */
PHP_FUNCTION(fdf_add_template)
{
@@ -574,15 +883,14 @@
err = FDFAddTemplate(fdf, Z_LVAL_PP(newpage), &filespec,
Z_STRVAL_PP(template), Z_LVAL_PP(rename));
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error adding template: %s into fdf
document", get_active_function_name(TSRMLS_C), Z_STRVAL_PP(template));
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
- RETURN_TRUE;
+ FDF_SUCCESS;
}
/* }}} */
-/* {{{ proto bool fdf_set_flags(int fdfdoc, string fieldname, int whichflags, int
newflags)
+/* {{{ proto bool fdf_set_flags(resource fdfdoc, string fieldname, int whichflags,
+int newflags)
Sets flags for a field in the FDF document */
PHP_FUNCTION(fdf_set_flags)
{
@@ -602,15 +910,43 @@
err=FDFSetFlags(fdf, Z_STRVAL_PP(fieldname), Z_LVAL_PP(flags),
Z_LVAL_PP(newflags));
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting flags for field: %s",
get_active_function_name(TSRMLS_C), Z_STRVAL_PP(fieldname));
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
- RETURN_TRUE;
+ FDF_SUCCESS;
}
/* }}} */
-/* {{{ proto bool fdf_set_opt(int fdfdoc, string fieldname, int element, string
value, string name)
+/* {{{ proto int fdf_get_flags(resorce fdfdoc, string fieldname, int whichflags)
+ Gets the flags of a field */
+PHP_FUNCTION(fdf_get_flags) {
+ zval *r_fdf;
+ char *fieldname;
+ int fieldname_len, whichflags;
+ FDFDoc fdf;
+ FDFErc err;
+ ASUns32 flags;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsl",
+ &r_fdf, &fieldname,
+&fieldname_len,
+ &whichflags)
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ err = FDFGetFlags(fdf, fieldname, (FDFItem)whichflags, &flags);
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+
+ RETURN_LONG((long)flags);
+}
+/* }}} */
+
+/* {{{ proto bool fdf_set_opt(resource fdfdoc, string fieldname, int element, string
+value, string name)
Sets a value in the opt array for a field */
PHP_FUNCTION(fdf_set_opt)
{
@@ -631,14 +967,69 @@
err = FDFSetOpt(fdf, Z_STRVAL_PP(fieldname), Z_LVAL_PP(element),
Z_STRVAL_PP(value), Z_STRVAL_PP(name));
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting FDF option for field: %s",
get_active_function_name(TSRMLS_C), Z_STRVAL_PP(fieldname));
- RETURN_FALSE;
+ FDF_FAILURE(err);
+ }
+ FDF_SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto mixed fdf_get_option(resource fdfdof, string fieldname [, int element])
+ Gets a value from the opt array of a field */
+PHP_FUNCTION(fdf_get_opt) {
+ zval *r_fdf;
+ char *fieldname;
+ int fieldname_len, element = -1;
+ FDFDoc fdf;
+ FDFErc err;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l",
+ &r_fdf, &fieldname,
+&fieldname_len,
+ &element)
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ if(element == -1) {
+ ASInt32 elements;
+ err = FDFGetOpt(fdf, fieldname, (ASInt32)-1, NULL, NULL, 0, &elements);
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+ RETURN_LONG((long)elements);
+ } else {
+ ASInt32 bufSize, nRet;
+ char *buf1, *buf2;
+
+ bufSize = 1024;
+ buf1 = emalloc(bufSize);
+ buf2 = emalloc(bufSize);
+
+ err = FDFGetOpt(fdf, fieldname, (ASInt32)element, buf1, buf2, bufSize,
+&nRet);
+ if(err == FDFErcBufTooShort) {
+ efree(buf1);
+ efree(buf2);
+ buf1 = emalloc(nRet);
+ buf2 = emalloc(nRet);
+ bufSize = nRet;
+ err = FDFGetOpt(fdf, fieldname, (ASInt32)element, buf1, buf2,
+bufSize, &nRet);
+ }
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+ if (array_init(return_value) == FAILURE) {
+ RETURN_FALSE;
+ }
+ add_next_index_stringl(return_value, buf1, strlen(buf1), 1);
+ add_next_index_stringl(return_value, buf2, strlen(buf2), 1);
+ efree(buf1);
+ efree(buf2);
}
- RETURN_TRUE;
}
/* }}} */
-/* {{{ proto bool fdf_set_submit_form_action(int fdfdoc, string fieldname, int
whichtrigger, string url, int flags)
+/* {{{ proto bool fdf_set_submit_form_action(resource fdfdoc, string fieldname, int
+whichtrigger, string url, int flags)
Sets the submit form action for a field */
PHP_FUNCTION(fdf_set_submit_form_action)
{
@@ -659,14 +1050,13 @@
err = FDFSetSubmitFormAction(fdf, Z_STRVAL_PP(fieldname), Z_LVAL_PP(trigger),
Z_STRVAL_PP(url), Z_LVAL_PP(flags));
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting FDF submit action for field:
%s", get_active_function_name(TSRMLS_C), Z_STRVAL_PP(fieldname));
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
- RETURN_TRUE;
+ FDF_SUCCESS;
}
/* }}} */
-/* {{{ proto bool fdf_set_javascript_action(int fdfdoc, string fieldname, int
whichtrigger, string script)
+/* {{{ proto bool fdf_set_javascript_action(resource fdfdoc, string fieldname, int
+whichtrigger, string script)
Sets the javascript action for a field */
PHP_FUNCTION(fdf_set_javascript_action)
{
@@ -686,10 +1076,9 @@
err = FDFSetJavaScriptAction(fdf, Z_STRVAL_PP(fieldname), Z_LVAL_PP(trigger),
Z_STRVAL_PP(script));
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting FDF javascript action for
field: %s", get_active_function_name(TSRMLS_C), Z_STRVAL_PP(fieldname));
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
- RETURN_TRUE;
+ FDF_SUCCESS;
}
/* }}} */
@@ -712,10 +1101,9 @@
err = FDFSetEncoding(fdf, Z_STRVAL_PP(enc));
if(err != FDFErcOK) {
- php_error(E_WARNING, "%s(): Error setting FDF encoding: %s",
get_active_function_name(TSRMLS_C), Z_STRVAL_PP(enc));
- RETURN_FALSE;
+ FDF_FAILURE(err);
}
- RETURN_TRUE;
+ FDF_SUCCESS;
}
/* }}} */
@@ -789,6 +1177,387 @@
}
/* }}} */
+/* {{{ int fdf_errno(void)
+ Gets error code for last operation */
+PHP_FUNCTION(fdf_errno) {
+ RETURN_LONG((long)FDF_G(error));
+}
+/* }}} */
+
+/* {{{ string fdf_error([int errno])
+ Gets error description for error code */
+PHP_FUNCTION(fdf_error) {
+ FDFErc err;
+ long p_err = -1;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &p_err)
+ == FAILURE) {
+ return;
+ }
+
+ err = (p_err >= 0) ? (FDFErc)p_err : FDF_G(error);
+
+ switch(err) {
+ case FDFErcOK:
+ RETURN_STRING("no error", 1);
+ case FDFErcInternalError:
+ RETURN_STRING("An internal FDF Library error occurred", 1);
+ case FDFErcBadParameter:
+ RETURN_STRING("One or more of the parameters passed were invalid. ",
+1);
+ case FDFErcFileSysErr:
+ RETURN_STRING("A file system error occurred or the file was not
+found", 1);
+ case FDFErcBadFDF:
+ RETURN_STRING("The FDF file being opened or parsed was invalid", 1);
+ case FDFErcFieldNotFound:
+ RETURN_STRING("The field whose name was passed in the parameter
+fieldName does not exist in the FDF file", 1);
+ case FDFErcNoValue:
+ RETURN_STRING("The field whose value was requested has no value", 1);
+ case FDFErcEnumStopped:
+ RETURN_STRING("Enumeration was stopped by FDFEnumValues by returning
+FALSE", 1);
+ case FDFErcCantInsertField:
+ RETURN_STRING("The field whose name was passed in the parameter
+fieldName cannot be inserted into the FDF file", 1);
+ case FDFErcNoOption:
+ RETURN_STRING("The requested element in a fields /Opt key does not
+exist, or the field has no /Opt key. ", 1);
+ case FDFErcNoFlags:
+ RETURN_STRING("The field has no /F or /Ff keys", 1);
+ case FDFErcBadPDF:
+ RETURN_STRING("The PDF file passed as the parameter to FDFSetAP was
+invalid, or did not contain the requested page ", 1);
+ case FDFErcBufTooShort:
+ RETURN_STRING("The buffer passed as a parameter was too short", 1);
+ case FDFErcNoAP:
+ RETURN_STRING("The field has no /AP key", 1);
+ case FDFErcIncompatibleFDF:
+ RETURN_STRING("An attempt to mix classic and template-based FDF files
+was made", 1);
+ case FDFErcNoAppendSaves:
+ RETURN_STRING("The FDF does not include a /Difference key", 1);
+ case FDFErcValueIsArray:
+ RETURN_STRING("The value of this field is an array. Use
+FDFGetNthValue. ", 1);
+ case FDFErcEmbeddedFDFs:
+ RETURN_STRING("The FDF you passed as a parameter is a container for
+one or more FDFs embedded within it. Use FDFOpenFromEmbedded to gain access to each
+embedded FDF", 1);
+ case FDFErcNoMoreFDFs:
+ RETURN_STRING("Returned by FDFOpenFromEmbedded when parameter iWhich
+>= the number of embedded FDFs (including the case when the passed FDF does not
+contain any embedded FDFs)", 1);
+ case FDFErcInvalidPassword:
+ RETURN_STRING("Returned by FDFOpenFromEmbedded when the embedded FDF
+is encrypted, and you did not provide the correct password", 1);
+ case FDFErcLast:
+ RETURN_STRING("Reserved for future use", 1);
+ default:
+ RETURN_STRING("unknown error", 1);
+ }
+}
+/* }}} */
+
+/* {{{ proto string fdf_get_version([resource fdfdoc])
+ Gets version number for FDF api or file */
+PHP_FUNCTION(fdf_get_version) {
+ zval *r_fdf = NULL;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &r_fdf)
+ == FAILURE) {
+ return;
+ }
+
+ if(r_fdf) {
+ const char *fdf_version;
+ FDFDoc fdf;
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+ fdf_version = FDFGetFDFVersion(fdf);
+ RETURN_STRING((char *)fdf_version, 1);
+ } else {
+ const char *api_version = FDFGetVersion();
+ RETURN_STRING((char *)api_version, 1);
+ }
+}
+/* }}} */
+
+/* {{{ proto bool fdf_set_version(resourece fdfdoc, string version)
+ Sets FDF version for a file*/
+PHP_FUNCTION(fdf_set_version) {
+ zval *r_fdf;
+ char *version;
+ int version_len;
+ FDFDoc fdf;
+ FDFErc err;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &r_fdf, &version,
+&version_len)
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ err = FDFSetFDFVersion(fdf, version);
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+ FDF_SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto bool fdf_add_doc_javascript(resource fdfdoc, string scriptname, string
+script)
+ Add javascript code to the fdf file */
+PHP_FUNCTION(fdf_add_doc_javascript) {
+ zval *r_fdf;
+ char *name, *script;
+ int name_len, script_len;
+ FDFDoc fdf;
+ FDFErc err;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &r_fdf,
+ &name, &name_len,
+ &script, &script_len
+ )
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ err = FDFAddDocJavaScript(fdf, name, script);
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+ FDF_SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto bool fdf_set_on_import_javascript(resource fdfdoc, string script [, bool
+before_data_import])
+ Adds javascript code to be executed when Acrobat opens the FDF */
+PHP_FUNCTION(fdf_set_on_import_javascript) {
+ zval *r_fdf;
+ char *script;
+ int script_len;
+ zend_bool before;
+ FDFDoc fdf;
+ FDFErc err;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsb", &r_fdf,
+ &script, &script_len, &before
+ )
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ err = FDFSetOnImportJavaScript(fdf, script, before);
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+ FDF_SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto bool fdf_set_target_frame(resource fdfdoc, string target)
+ Sets target frame for form */
+PHP_FUNCTION(fdf_set_target_frame) {
+ zval *r_fdf;
+ char *target;
+ int target_len;
+ FDFDoc fdf;
+ FDFErc err;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &r_fdf,
+ &target, &target_len
+ )
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ err = FDFSetTargetFrame(fdf, target);
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+ FDF_SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto bool fdf_remove_item(resource fdfdoc, string fieldname, int item)
+ Sets target frame for form */
+PHP_FUNCTION(fdf_remove_item) {
+ zval *r_fdf;
+ char *fieldname;
+ int fieldname_len;
+ long item;
+ FDFDoc fdf;
+ FDFErc err;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsl", &r_fdf,
+ &fieldname, &fieldname_len
+ )
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ err = FDFRemoveItem(fdf, *fieldname ? fieldname : NULL, item);
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+ FDF_SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto array fdf_get_attachment(resource fdfdoc, string fieldname, string
+savepath)
+ Get attached uploaded file */
+PHP_FUNCTION(fdf_get_attachment) {
+ zval *r_fdf;
+ char *fieldname, *savepath;
+ int fieldname_len, savepath_len;
+ int is_dir=0;
+ FDFDoc fdf;
+ FDFErc err;
+ char pathbuf[MAXPATHLEN], mimebuf[1024];
+ struct stat statBuf;
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rss", &r_fdf,
+ &fieldname, &fieldname_len,
+ &savepath, &savepath_len
+ )
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ strncpy(pathbuf , savepath, MAXPATHLEN-1);
+ pathbuf[MAXPATHLEN-1] = '\0';
+
+ if(0 == stat(pathbuf, &statBuf)) {
+ is_dir = S_ISDIR(statBuf.st_mode);
+ }
+
+ err = FDFExtractAttachment(fdf, fieldname, pathbuf, sizeof(pathbuf), is_dir,
+mimebuf, sizeof(mimebuf));
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+
+ if (array_init(return_value) == FAILURE) {
+ RETURN_FALSE;
+ }
+ add_assoc_string(return_value, "path", pathbuf, 1);
+ add_assoc_string(return_value, "type", mimebuf, 1);
+ stat(pathbuf, &statBuf);
+ add_assoc_long(return_value, "size", statBuf.st_size);
+}
+/* }}} */
+
+/* {{{ enum_values_callback */
+ static ASBool enum_values_callback(char *name, char *value, void *userdata) {
+ zval *retval_ptr, *z_name, *z_value, **args[3];
+ long retval = 0;
+ int numargs = 2;
+ TSRMLS_FETCH();
+
+ MAKE_STD_ZVAL(z_name);
+ ZVAL_STRING(z_name, name, 1);
+ args[0] = &z_name;
+
+ if(*value) { // simple value
+ MAKE_STD_ZVAL(z_value);
+ ZVAL_STRING(z_value, value, 1);
+ args[1] = &z_value;
+ } else { // empty value *might* be an array
+ // todo do it like fdf_get_value (or re-implement yourself?)
+ }
+
+ if(userdata) {
+ args[2] = (zval **)userdata;
+ numargs++;
+ }
+
+ if (call_user_function_ex(EG(function_table),
+ NULL,
+ FDF_G(enum_callback),
+ &retval_ptr,
+ numargs, args,
+ 0, NULL
+TSRMLS_CC)==SUCCESS
+ && retval_ptr) {
+
+ convert_to_long_ex(&retval_ptr);
+ retval = Z_LVAL_P(retval_ptr);
+ zval_ptr_dtor(&retval_ptr);
+ } else {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "callback failed");
+ }
+
+ zval_ptr_dtor(&z_name);
+ zval_ptr_dtor(&z_value);
+
+ return retval;
+ }
+/* }}} */
+
+/* {{{ proto bool fdf_enum_values(resource fdfdoc, mixed callback [, mixed userdata])
+ */
+PHP_FUNCTION(fdf_enum_values) {
+ zval *r_fdf;
+ zval *callback;
+ zval *userdata = NULL;
+ FDFDoc fdf;
+ FDFErc err;
+ char *name;
+ char namebuf[1024], valbuf[1024];
+
+ if(zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &r_fdf,
+ &callback, &userdata
+ )
+ == FAILURE) {
+ return;
+ }
+
+ ZEND_FETCH_RESOURCE(fdf, FDFDoc *, &r_fdf, -1, "fdf", le_fdf);
+
+ if (Z_TYPE_P(callback) != IS_ARRAY &&
+ Z_TYPE_P(callback) != IS_STRING) {
+ php_error_docref(NULL TSRMLS_CC, E_WARNING, "Wrong syntax for function
+name");
+ RETURN_FALSE;
+ }
+
+ convert_to_string_ex(&callback);
+
+ if (!zend_is_callable(callback, 0, &name)) {
+ php_error_docref1(NULL TSRMLS_CC, name, E_WARNING, "Second argument is
+expected to be a valid callback");
+ efree(name);
+ RETURN_FALSE;
+ }
+ efree(name);
+ FDF_G(enum_callback) = callback;
+ FDF_G(enum_fdf) = fdf;
+
+ err = FDFEnumValues(fdf, enum_values_callback,
+ namebuf, sizeof(namebuf),
+ valbuf, sizeof(valbuf),
+ userdata ? &userdata : NULL, 0);
+
+ if(err != FDFErcOK) {
+ FDF_FAILURE(err);
+ }
+ FDF_SUCCESS;
+}
+/* }}} */
+
+/* {{{ proto fdf_header()
+ Set FDF specific HTTP headers */
+PHP_FUNCTION(fdf_header) {
+ sapi_header_line ctr = {0};
+
+ ctr.line = "Content-type: application/vnd.fdf";
+ ctr.line_len = strlen(ctr.line);
+ ctr.response_code = 200;
+
+ sapi_header_op(SAPI_HEADER_REPLACE, &ctr TSRMLS_CC);
+}
+/* }}} */
#endif
Index: php4/ext/fdf/php_fdf.h
diff -u php4/ext/fdf/php_fdf.h:1.17 php4/ext/fdf/php_fdf.h:1.18
--- php4/ext/fdf/php_fdf.h:1.17 Tue Mar 19 19:39:28 2002
+++ php4/ext/fdf/php_fdf.h Mon Oct 21 15:55:28 2002
@@ -16,7 +16,7 @@
+----------------------------------------------------------------------+
*/
-/* $Id: php_fdf.h,v 1.17 2002/03/20 00:39:28 sniper Exp $ */
+/* $Id: php_fdf.h,v 1.18 2002/10/21 19:55:28 hholzgra Exp $ */
#ifndef PHP_FDF_H
#define PHP_FDF_H
@@ -33,32 +33,62 @@
# include <FdfTk.h>
#endif
+ZEND_BEGIN_MODULE_GLOBALS(fdf)
+ FDFErc error;
+ zval *enum_callback;
+ FDFDoc enum_fdf;
+ZEND_END_MODULE_GLOBALS(fdf)
+
+#ifdef ZTS
+#define FDF_G(v) TSRMG(fdf_globals_id, zend_fdf_globals *, v)
+#else
+#define FDF_G(v) (fdf_globals.v)
+#endif
+
+
extern zend_module_entry fdf_module_entry;
#define fdf_module_ptr &fdf_module_entry
PHP_MINIT_FUNCTION(fdf);
PHP_MSHUTDOWN_FUNCTION(fdf);
+PHP_RINIT_FUNCTION(fdf);
PHP_MINFO_FUNCTION(fdf);
PHP_FUNCTION(fdf_open);
+PHP_FUNCTION(fdf_open_string);
PHP_FUNCTION(fdf_close);
PHP_FUNCTION(fdf_create);
PHP_FUNCTION(fdf_save);
+PHP_FUNCTION(fdf_save_string);
PHP_FUNCTION(fdf_get_value);
PHP_FUNCTION(fdf_set_value);
PHP_FUNCTION(fdf_next_field_name);
PHP_FUNCTION(fdf_set_ap);
+PHP_FUNCTION(fdf_get_ap);
PHP_FUNCTION(fdf_get_status);
PHP_FUNCTION(fdf_set_status);
PHP_FUNCTION(fdf_set_file);
PHP_FUNCTION(fdf_get_file);
PHP_FUNCTION(fdf_add_template);
PHP_FUNCTION(fdf_set_flags);
+PHP_FUNCTION(fdf_get_flags);
PHP_FUNCTION(fdf_set_opt);
+PHP_FUNCTION(fdf_get_opt);
PHP_FUNCTION(fdf_set_submit_form_action);
PHP_FUNCTION(fdf_set_javascript_action);
+PHP_FUNCTION(fdf_add_doc_javascript);
+PHP_FUNCTION(fdf_set_on_import_javascript);
PHP_FUNCTION(fdf_set_encoding);
-
+PHP_FUNCTION(fdf_get_encoding);
+PHP_FUNCTION(fdf_set_version);
+PHP_FUNCTION(fdf_get_version);
+PHP_FUNCTION(fdf_set_target_frame);
+PHP_FUNCTION(fdf_errno);
+PHP_FUNCTION(fdf_error);
+PHP_FUNCTION(fdf_remove_item);
+PHP_FUNCTION(fdf_get_attachment);
+PHP_FUNCTION(fdf_enum_values);
+PHP_FUNCTION(fdf_header);
#else
#define fdf_module_ptr NULL
#endif
--
PHP CVS Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php
