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;
}
/* {{{ proto string XMLReader::getAttributeNs(string name, string namespaceURI)
Get value of a attribute via name and namespace from current element */
PHP_METHOD(xmlreader, getAttributeNs)
{
zval *id;
size_t name_len = 0, ns_uri_len = 0;
xmlreader_object *intern;
char *name, *ns_uri, *retchar = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "ss", &name, &name_len, &ns_uri, &ns_uri_len) == FAILURE) {
return;
}
if (name_len == 0 || ns_uri_len == 0) {
php_error_docref(NULL, E_WARNING, "Attribute Name and Namespace URI cannot be empty");
RETURN_FALSE;
}
id = getThis();
intern = Z_XMLREADER_P(id);
if (intern && intern->ptr) {
retchar = (char *)xmlTextReaderGetAttributeNs(intern->ptr, (xmlChar *)name, (xmlChar *)ns_uri);
}
if (retchar) {
RETVAL_STRING(retchar);
xmlFree(retchar);
}
}
/* {{{ php_xmlreader_string_arg */
static void php_xmlreader_string_arg(INTERNAL_FUNCTION_PARAMETERS, xmlreader_read_one_char_t internal_function) {
zval *id;
size_t name_len = 0;
char *retchar = NULL;
xmlreader_object *intern;
char *name;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &name, &name_len) == FAILURE) {
return;
}
if (!name_len) {
php_error_docref(NULL, E_WARNING, "Argument cannot be an empty string");
RETURN_FALSE;
}
id = getThis();
intern = Z_XMLREADER_P(id);
if (intern && intern->ptr) {
retchar = (char *)internal_function(intern->ptr, (const unsigned char *)name);
}
if (retchar) {
RETVAL_STRING(retchar);
xmlFree(retchar);
return;
} else {
RETVAL_NULL();
}
}
/* {{{ proto string base_convert(string number, int frombase, int tobase)
Converts a number in a string from any base <= 36 to any base <= 36.
*/
void php3_base_convert(INTERNAL_FUNCTION_PARAMETERS)
{
pval *number, *frombase, *tobase, temp;
char *result;
if (ARG_COUNT(ht) != 3 || getParameters(ht, 3, &number, &frombase, &tobase)
== FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string(number);
convert_to_long(frombase);
convert_to_long(tobase);
if (frombase->value.lval < 2 || frombase->value.lval > 36) {
php3_error(E_WARNING, "base_convert: invalid `from base' (%d)",
frombase->value.lval);
RETURN_FALSE;
}
if (tobase->value.lval < 2 || tobase->value.lval > 36) {
php3_error(E_WARNING, "base_convert: invalid `to base' (%d)",
tobase->value.lval);
RETURN_FALSE;
}
temp.type = IS_LONG;
temp.value.lval = _php3_basetolong(number, frombase->value.lval);
result = _php3_longtobase(&temp, tobase->value.lval);
RETVAL_STRING(result, 0);
} /* }}} */
/**
* Gets HTTP schema (http/https)
*
* @return string
*/
PHP_METHOD(Phalcon_Http_Request, getScheme){
zval https_header = {}, https = {};
PHALCON_STR(&https_header, "HTTPS");
PHALCON_CALL_METHODW(&https, getThis(), "getserver", &https_header);
if (zend_is_true(&https)) {
if (PHALCON_IS_STRING(&https, "off")) {
RETVAL_STRING("http");
} else {
RETVAL_STRING("https");
}
} else {
RETVAL_STRING("http");
}
}
/* {{{
* Gets the value from ICU , called when PHP userspace function is called
* common code shared by get_primary_language,get_script or get_region or get_variant
*/
static void get_icu_value_src_php( char* tag_name, INTERNAL_FUNCTION_PARAMETERS)
{
const char* loc_name = NULL;
size_t loc_name_len = 0;
char* tag_value = NULL;
char* empty_result = "";
int result = 0;
char* msg = NULL;
UErrorCode status = U_ZERO_ERROR;
intl_error_reset( NULL );
if(zend_parse_parameters( ZEND_NUM_ARGS(), "s",
&loc_name ,&loc_name_len ) == FAILURE) {
spprintf(&msg , 0, "locale_get_%s : unable to parse input params", tag_name );
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, msg , 1 );
efree(msg);
RETURN_FALSE;
}
if(loc_name_len == 0) {
loc_name = intl_locale_get_default();
}
/* Call ICU get */
tag_value = get_icu_value_internal( loc_name , tag_name , &result ,0);
/* No value found */
if( result == -1 ) {
if( tag_value){
efree( tag_value);
}
RETURN_STRING( empty_result);
}
/* value found */
if( tag_value){
RETVAL_STRING( tag_value );
//???
efree(tag_value);
return;
}
/* Error encountered while fetching the value */
if( result ==0) {
spprintf(&msg , 0, "locale_get_%s : unable to get locale %s", tag_name , tag_name );
intl_error_set( NULL, status, msg , 1 );
efree(msg);
RETURN_NULL();
}
}
/**
* Returns the type of a variable as a string
*/
void zephir_gettype(zval *return_value, zval *arg)
{
switch (Z_TYPE_P(arg)) {
case IS_NULL:
RETVAL_STRING("NULL");
break;
case IS_TRUE:
case IS_FALSE:
RETVAL_STRING("boolean");
break;
case IS_LONG:
RETVAL_STRING("integer");
break;
case IS_DOUBLE:
RETVAL_STRING("double");
break;
case IS_STRING:
RETVAL_STRING("string");
break;
case IS_ARRAY:
RETVAL_STRING("array");
break;
case IS_OBJECT:
RETVAL_STRING("object");
break;
case IS_RESOURCE:
{
const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg));
if (type_name) {
RETVAL_STRING("resource");
break;
}
}
default:
RETVAL_STRING("unknown type");
}
}
/* {{{ MongoRegex::__toString()
*/
PHP_METHOD(MongoRegex, __toString)
{
char *field_name;
zval *zre = zend_read_property(mongo_ce_Regex, getThis(), "regex", strlen("regex"), NOISY TSRMLS_CC);
zval *zopts = zend_read_property(mongo_ce_Regex, getThis(), "flags", strlen("flags"), NOISY TSRMLS_CC);
char *re = Z_STRVAL_P(zre);
char *opts = Z_STRVAL_P(zopts);
spprintf(&field_name, 0, "/%s/%s", re, opts);
RETVAL_STRING(field_name, 0);
}
/* {{{ proto string escapeshellcmd(string command)
Escape shell metacharacters */
void php3_escapeshellcmd(INTERNAL_FUNCTION_PARAMETERS)
{
pval *arg1;
char *cmd;
TLS_VARS;
if (getParameters(ht, 1, &arg1) == FAILURE) {
WRONG_PARAM_COUNT;
}
cmd = _php3_escapeshellcmd(arg1->value.str.val);
RETVAL_STRING(cmd,1);
efree(cmd);
}
/**
* Generates a unique id for a path
*/
void zephir_unique_path_key(zval *return_value, zval *path)
{
unsigned long h;
char *strKey;
if (Z_TYPE_P(path) != IS_STRING) {
return;
}
h = zend_hash_func(Z_STRVAL_P(path), Z_STRLEN_P(path) + 1);
strKey = emalloc(24);
sprintf(strKey, "v%lu", h);
RETVAL_STRING(strKey);
efree(strKey);
}
/* {{{ php_xmlreader_no_arg_string */
static void php_xmlreader_no_arg_string(INTERNAL_FUNCTION_PARAMETERS, xmlreader_read_char_t internal_function) {
zval *id;
char *retchar = NULL;
xmlreader_object *intern;
id = getThis();
intern = Z_XMLREADER_P(id);
if (intern && intern->ptr) {
retchar = (char *)internal_function(intern->ptr);
}
if (retchar) {
RETVAL_STRING(retchar);
xmlFree(retchar);
return;
} else {
RETVAL_EMPTY_STRING();
}
}
ZEND_METHOD( alinq_class , getArrayItem )
{
zval *data_array;
zval *copy_array;
char *name;
int name_len;
zval **fooval;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "as",&data_array, &name, &name_len) == FAILURE) {
RETURN_NULL();
}
if(zend_hash_find(HASH_OF(data_array),name,name_len,(void**)&fooval) == SUCCESS ){
RETVAL_ZVAL(*fooval, 1, 0);
}else{
RETVAL_STRING("index_not_found", 1);
}
return;
}
static PHP_FUNCTION(dbxml_version)
{
int M, m, p;
zval *maj = NULL, *min = NULL, *pat = NULL;
if (ZEND_NUM_ARGS() && FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z/z/z/", &maj, &min, &pat)) {
return;
}
RETVAL_STRING((char*)dbxml_version(&M, &m, &p), (int)1);
if (ZEND_NUM_ARGS()) {
convert_to_long(maj);
convert_to_long(min);
convert_to_long(pat);
Z_LVAL_P(maj) = M;
Z_LVAL_P(min) = m;
Z_LVAL_P(pat) = p;
}
}
/* {{{ proto string XMLReader::getAttributeNo(int index)
Get value of an attribute at index from current element */
PHP_METHOD(xmlreader, getAttributeNo)
{
zval *id;
zend_long attr_pos;
char *retchar = NULL;
xmlreader_object *intern;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &attr_pos) == FAILURE) {
return;
}
id = getThis();
intern = Z_XMLREADER_P(id);
if (intern && intern->ptr) {
retchar = (char *)xmlTextReaderGetAttributeNo(intern->ptr, attr_pos);
}
if (retchar) {
RETVAL_STRING(retchar);
xmlFree(retchar);
}
}
/* {{{ proto string getTextString()
Get the text string for a label object. */
PHP_METHOD(labelObj, getTextString)
{
zval *zobj = getThis();
php_label_object *php_label;
char *value = NULL;
PHP_MAPSCRIPT_ERROR_HANDLING(TRUE);
if (zend_parse_parameters_none() == FAILURE) {
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
return;
}
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
php_label = (php_label_object *) zend_object_store_get_object(zobj TSRMLS_CC);
value = labelObj_getTextString(php_label->label);
if (value == NULL)
RETURN_STRING("", 1);
RETVAL_STRING(value, 1);
free(value);
}
/* {{{ proto string cluster.getFilterString()
Return the cluster's filter expression. Returns NULL on error. */
PHP_METHOD(clusterObj, getFilterString)
{
zval *zobj = getThis();
char *value = NULL;
php_cluster_object *php_cluster;
PHP_MAPSCRIPT_ERROR_HANDLING(TRUE);
if (zend_parse_parameters_none() == FAILURE) {
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
return;
}
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
php_cluster = (php_cluster_object *) zend_object_store_get_object(zobj TSRMLS_CC);
value = clusterObj_getFilterString(php_cluster->cluster);
if (value == NULL) {
RETURN_NULL();
}
RETVAL_STRING(value, 1);
free(value);
}
/* {{{ proto string convertToString()
Convert the referencemap object to string. */
PHP_METHOD(referenceMapObj, convertToString)
{
zval *zobj = getThis();
php_referencemap_object *php_referencemap;
char *value = NULL;
PHP_MAPSCRIPT_ERROR_HANDLING(TRUE);
if (zend_parse_parameters_none() == FAILURE) {
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
return;
}
PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE);
php_referencemap = (php_referencemap_object *) zend_object_store_get_object(zobj TSRMLS_CC);
value = referenceMapObj_convertToString(php_referencemap->referencemap);
if (value == NULL)
RETURN_STRING("", 1);
RETVAL_STRING(value, 1);
free(value);
}
static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
{
zval *id, retval, *context = NULL;
xmlXPathContextPtr ctxp;
xmlNodePtr nodep = NULL;
xmlXPathObjectPtr xpathobjp;
size_t expr_len, nsnbr = 0, xpath_type;
dom_xpath_object *intern;
dom_object *nodeobj;
char *expr;
xmlDoc *docp = NULL;
xmlNsPtr *ns = NULL;
zend_bool register_node_ns = 1;
if (zend_parse_method_parameters(ZEND_NUM_ARGS(), getThis(), "Os|O!b", &id, dom_xpath_class_entry, &expr, &expr_len, &context, dom_node_class_entry, ®ister_node_ns) == FAILURE) {
return;
}
intern = Z_XPATHOBJ_P(id);
ctxp = (xmlXPathContextPtr) intern->dom.ptr;
if (ctxp == NULL) {
php_error_docref(NULL, E_WARNING, "Invalid XPath Context");
RETURN_FALSE;
}
docp = (xmlDocPtr) ctxp->doc;
if (docp == NULL) {
php_error_docref(NULL, E_WARNING, "Invalid XPath Document Pointer");
RETURN_FALSE;
}
if (context != NULL) {
DOM_GET_OBJ(nodep, context, xmlNodePtr, nodeobj);
}
if (!nodep) {
nodep = xmlDocGetRootElement(docp);
}
if (nodep && docp != nodep->doc) {
php_error_docref(NULL, E_WARNING, "Node From Wrong Document");
RETURN_FALSE;
}
ctxp->node = nodep;
if (register_node_ns) {
/* Register namespaces in the node */
ns = xmlGetNsList(docp, nodep);
if (ns != NULL) {
while (ns[nsnbr] != NULL)
nsnbr++;
}
}
ctxp->namespaces = ns;
ctxp->nsNr = nsnbr;
xpathobjp = xmlXPathEvalExpression((xmlChar *) expr, ctxp);
ctxp->node = NULL;
if (ns != NULL) {
xmlFree(ns);
ctxp->namespaces = NULL;
ctxp->nsNr = 0;
}
if (! xpathobjp) {
RETURN_FALSE;
}
if (type == PHP_DOM_XPATH_QUERY) {
xpath_type = XPATH_NODESET;
} else {
xpath_type = xpathobjp->type;
}
switch (xpath_type) {
case XPATH_NODESET:
{
int i;
xmlNodeSetPtr nodesetp;
array_init(&retval);
if (xpathobjp->type == XPATH_NODESET && NULL != (nodesetp = xpathobjp->nodesetval)) {
for (i = 0; i < nodesetp->nodeNr; i++) {
xmlNodePtr node = nodesetp->nodeTab[i];
zval child;
if (node->type == XML_NAMESPACE_DECL) {
xmlNsPtr curns;
xmlNodePtr nsparent;
nsparent = node->_private;
curns = xmlNewNs(NULL, node->name, NULL);
if (node->children) {
curns->prefix = xmlStrdup((xmlChar *) node->children);
}
if (node->children) {
node = xmlNewDocNode(docp, NULL, (xmlChar *) node->children, node->name);
} else {
node = xmlNewDocNode(docp, NULL, (xmlChar *) "xmlns", node->name);
}
node->type = XML_NAMESPACE_DECL;
node->parent = nsparent;
node->ns = curns;
}
php_dom_create_object(node, &child, &intern->dom);
add_next_index_zval(&retval, &child);
}
}
php_dom_create_interator(return_value, DOM_NODELIST);
nodeobj = Z_DOMOBJ_P(return_value);
dom_xpath_iter(&retval, nodeobj);
break;
}
case XPATH_BOOLEAN:
RETVAL_BOOL(xpathobjp->boolval);
break;
case XPATH_NUMBER:
RETVAL_DOUBLE(xpathobjp->floatval)
break;
case XPATH_STRING:
RETVAL_STRING((char *) xpathobjp->stringval);
break;
default:
RETVAL_NULL();
break;
}
xmlXPathFreeObject(xpathobjp);
}
/*
* Generic SNMP object fetcher
*
* st=1 GET
* st=2 WALK
*/
void _php3_snmp(INTERNAL_FUNCTION_PARAMETERS, int st) {
pval *a1, *a2, *a3;
struct snmp_session session, *ss;
struct snmp_pdu *pdu=NULL, *response;
struct variable_list *vars;
char *community, *hostname;
char *objid;
oid name[MAX_NAME_LEN];
int name_length;
int status, count,rootlen=0,gotroot=0;
oid root[MAX_NAME_LEN];
char buf[2048];
int keepwalking=1;
static int mib_init=0;
if (getParameters(ht, 3, &a1, &a2, &a3) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string(a1);
convert_to_string(a2);
convert_to_string(a3);
hostname=a1->value.str.val;
community=a2->value.str.val;
objid=a3->value.str.val;
if (!mib_init) {
init_mib();
mib_init=1;
}
if (st==2) { /* walk */
rootlen = MAX_NAME_LEN;
if (strlen(objid)) { /* on a walk, an empty string means top of tree - no error */
if (read_objid(objid, root, &rootlen)) {
gotroot = 1;
} else {
php3_error(E_WARNING,"Invalid object identifier: %s\n", objid);
}
}
if (gotroot == 0) {
memmove((char *)root, (char *)objid_mib, sizeof(objid_mib));
rootlen = sizeof(objid_mib) / sizeof(oid);
gotroot = 1;
}
}
memset(&session, 0, sizeof(struct snmp_session));
session.peername = hostname;
session.version = SNMP_VERSION_1;
session.community = (u_char *)community;
session.community_len = strlen((char *)community);
session.retries = SNMP_DEFAULT_RETRIES;
session.timeout = SNMP_DEFAULT_TIMEOUT;
session.authenticator = NULL;
snmp_synch_setup(&session);
ss = snmp_open(&session);
if (ss == NULL){
php3_error(E_WARNING,"Couldn't open snmp\n");
RETURN_FALSE;
}
if (st==2) {
memmove((char *)name, (char *)root, rootlen * sizeof(oid));
name_length = rootlen;
/* prepare result array */
array_init(return_value);
}
while(keepwalking) {
keepwalking=0;
if (st==1) pdu = snmp_pdu_create(GET_REQ_MSG);
else if (st==2) pdu = snmp_pdu_create(GETNEXT_REQ_MSG);
if (st==1) {
name_length = MAX_NAME_LEN;
if (!read_objid(objid, name, &name_length)) {
php3_error(E_WARNING,"Invalid object identifier: %s\n", objid);
RETURN_FALSE;
}
}
snmp_add_null_var(pdu, name, name_length);
retry:
status = snmp_synch_response(ss, pdu, &response);
if (status == STAT_SUCCESS) {
if (response->errstat == SNMP_ERR_NOERROR) {
for(vars = response->variables; vars; vars = vars->next_variable) {
if (st==2 && (vars->name_length < rootlen || memcmp(root, vars->name, rootlen * sizeof(oid))))
continue; /* not part of this subtree */
sprint_value(buf,vars->name, vars->name_length, vars);
#if 0
Debug("snmp response is: %s\n",buf);
#endif
if (st==1) {
RETVAL_STRING(buf,1);
} else if (st==2) {
/* Add to returned array */
add_next_index_string(return_value,buf,1);
if (vars->type != SNMP_ENDOFMIBVIEW && vars->type != SNMP_NOSUCHOBJECT && vars->type != SNMP_NOSUCHINSTANCE) {
memmove((char *)name, (char *)vars->name,vars->name_length * sizeof(oid));
name_length = vars->name_length;
keepwalking = 1;
}
}
}
} else {
if (st!=2 || response->errstat != SNMP_ERR_NOSUCHNAME) {
php3_error(E_WARNING,"Error in packet.\nReason: %s\n", snmp_errstring(response->errstat));
if (response->errstat == SNMP_ERR_NOSUCHNAME) {
for(count=1, vars = response->variables; vars && count != response->errindex;
vars = vars->next_variable, count++);
if (vars) sprint_objid(buf,vars->name, vars->name_length);
php3_error(E_WARNING,"This name does not exist: %s\n",buf);
}
if (st==1) {
if ((pdu = snmp_fix_pdu(response, GET_REQ_MSG)) != NULL) goto retry;
} else if (st==2) {
if ((pdu = snmp_fix_pdu(response, GETNEXT_REQ_MSG)) != NULL) goto retry;
}
RETURN_FALSE;
}
}
} else if (status == STAT_TIMEOUT) {
php3_error(E_WARNING,"No Response from %s\n", hostname);
RETURN_FALSE;
} else { /* status == STAT_ERROR */
php3_error(E_WARNING,"An error occurred, Quitting\n");
RETURN_FALSE;
}
if (response) snmp_free_pdu(response);
} /* keepwalking */
snmp_close(ss);
}
/* {{{ proto string ora_columntype(int cursor, int column)
Get the type of an Oracle result column */
void php3_Ora_ColumnType(INTERNAL_FUNCTION_PARAMETERS)
{ /* cursor_index, column_index */
pval *argv[2];
int cursor_ind, colno;
oraCursor *cursor = NULL;
if (ARG_COUNT(ht) != 2 || getParametersArray(ht, 2, argv) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_long(argv[0]);
/* don't convert the column index yet, it might be the column name */
cursor_ind = argv[0]->value.lval;
/* Find the cursor */
if ((cursor = ora_get_cursor(list, cursor_ind)) == NULL) {
RETURN_FALSE;
}
convert_to_long(argv[1]);
colno = argv[1]->value.lval;
if (cursor->ncols == 0){
php3_error(E_WARNING, "No tuples available at this cursor index");
RETURN_FALSE;
}
if (colno >= cursor->ncols){
php3_error(E_WARNING, "Column index larger than number of columns");
RETURN_FALSE;
}
if (colno < 0){
php3_error(E_WARNING, "Column numbering starts at 0");
RETURN_FALSE;
}
switch (cursor->columns[colno].dbtype) {
case SQLT_CHR:
RETURN_STRINGL("VARCHAR2", 8, 1);
case SQLT_VCS:
case SQLT_AVC:
RETURN_STRINGL("VARCHAR", 7, 1);
case SQLT_STR:
case SQLT_AFC:
RETURN_STRINGL("CHAR", 4, 1);
case SQLT_NUM: case SQLT_INT:
case SQLT_FLT: case SQLT_UIN:
RETURN_STRINGL("NUMBER", 6, 1);
case SQLT_LNG:
RETURN_STRINGL("LONG", 4, 1);
case SQLT_LBI:
RETURN_STRINGL("LONG RAW", 8, 1);
case SQLT_RID:
RETURN_STRINGL("ROWID", 5, 1);
case SQLT_DAT:
RETURN_STRINGL("DATE", 4, 1);
#ifdef SQLT_CUR
case SQLT_CUR:
RETURN_STRINGL("CURSOR", 6, 1);
#endif
default:
{
char numbuf[21];
snprintf(numbuf, 20, "UNKNOWN(%d)", cursor->columns[colno].dbtype);
numbuf[20] = '\0';
RETVAL_STRING(numbuf,1);
}
}
}
/*
* Generic SNMP object fetcher
*
* st=1 snmpget() - query an agent and return a single value.
* st=2 snmpwalk() - walk the mib and return a single dimensional array
* containing the values.
* st=3 snmprealwalk() and snmpwalkoid() - walk the mib and return an
* array of oid,value pairs.
* st=5-8 ** Reserved **
* st=11 snmpset() - query an agent and set a single value
*
*/
void php_snmp(INTERNAL_FUNCTION_PARAMETERS, int st) {
zval **a1, **a2, **a3, **a4, **a5, **a6, **a7;
struct snmp_session session, *ss;
struct snmp_pdu *pdu=NULL, *response;
struct variable_list *vars;
char *objid;
oid name[MAX_NAME_LEN];
int name_length;
int status, count,rootlen=0,gotroot=0;
oid root[MAX_NAME_LEN];
char buf[2048];
char buf2[2048];
int keepwalking=1;
long timeout=SNMP_DEFAULT_TIMEOUT;
long retries=SNMP_DEFAULT_RETRIES;
int myargc = ZEND_NUM_ARGS();
char type = (char) 0;
char *value = (char *) 0;
if (myargc < 3 || myargc > 7 ||
zend_get_parameters_ex(myargc, &a1, &a2, &a3, &a4, &a5, &a6, &a7) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_string_ex(a1);
convert_to_string_ex(a2);
convert_to_string_ex(a3);
if (st == 11) {
if (myargc < 5) {
WRONG_PARAM_COUNT;
}
convert_to_string_ex(a4);
convert_to_string_ex(a5);
if(myargc > 5) {
convert_to_long_ex(a6);
timeout = (*a6)->value.lval;
}
if(myargc > 6) {
convert_to_long_ex(a7);
retries = (*a7)->value.lval;
}
type = (*a4)->value.str.val[0];
value = (*a5)->value.str.val;
} else {
if(myargc > 3) {
convert_to_long_ex(a4);
timeout = (*a4)->value.lval;
}
if(myargc > 4) {
convert_to_long_ex(a5);
retries = (*a5)->value.lval;
}
}
objid = (*a3)->value.str.val;
if (st >= 2) { /* walk */
rootlen = MAX_NAME_LEN;
if ( strlen(objid) ) { /* on a walk, an empty string means top of tree - no error */
if ( read_objid(objid, root, &rootlen) ) {
gotroot = 1;
} else {
php_error(E_WARNING,"Invalid object identifier: %s\n", objid);
}
}
if (gotroot == 0) {
memmove((char *)root, (char *)objid_mib, sizeof(objid_mib));
rootlen = sizeof(objid_mib) / sizeof(oid);
gotroot = 1;
}
}
memset(&session, 0, sizeof(struct snmp_session));
session.peername = (*a1)->value.str.val;
session.version = SNMP_VERSION_1;
/*
* FIXME: potential memory leak
* This is a workaround for an "artifact" (Mike Slifcak)
* in (at least) ucd-snmp 3.6.1 which frees
* memory it did not allocate
*/
#ifdef UCD_SNMP_HACK
session.community = (u_char *)strdup((*a2)->value.str.val); /* memory freed by SNMP library, strdup NOT estrdup */
#else
session.community = (u_char *)(*a2)->value.str.val;
#endif
session.community_len = (*a2)->value.str.len;
session.retries = retries;
session.timeout = timeout;
session.authenticator = NULL;
snmp_synch_setup(&session);
if ((ss = snmp_open(&session)) == NULL) {
php_error(E_WARNING,"Could not open snmp\n");
RETURN_FALSE;
}
if (st >= 2) {
memmove((char *)name, (char *)root, rootlen * sizeof(oid));
name_length = rootlen;
if (array_init(return_value) == FAILURE) {
php_error(E_WARNING, "Cannot prepare result array");
RETURN_FALSE;
}
}
while(keepwalking) {
keepwalking=0;
if (st == 1) {
pdu = snmp_pdu_create(SNMP_MSG_GET);
name_length = MAX_NAME_LEN;
if ( !read_objid(objid, name, &name_length) ) {
php_error(E_WARNING,"Invalid object identifier: %s\n", objid);
RETURN_FALSE;
}
snmp_add_null_var(pdu, name, name_length);
} else if (st == 11) {
pdu = snmp_pdu_create(SNMP_MSG_SET);
if (snmp_add_var(pdu, name, name_length, type, value)) {
php_error(E_WARNING,"Could not add variable: %s\n", name);
RETURN_FALSE;
}
} else if (st >= 2) {
pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
snmp_add_null_var(pdu, name, name_length);
}
retry:
status = snmp_synch_response(ss, pdu, &response);
if (status == STAT_SUCCESS) {
if (response->errstat == SNMP_ERR_NOERROR) {
for (vars = response->variables; vars; vars = vars->next_variable) {
if (st >= 2 && st != 11 &&
(vars->name_length < rootlen || memcmp(root, vars->name, rootlen * sizeof(oid)))) {
continue; /* not part of this subtree */
}
if (st != 11) {
sprint_value(buf,vars->name, vars->name_length, vars);
}
#if 0
Debug("snmp response is: %s\n",buf);
#endif
if (st == 1) {
RETVAL_STRING(buf,1);
} else if (st == 2) {
add_next_index_string(return_value,buf,1); /* Add to returned array */
} else if (st == 3) {
sprint_objid(buf2, vars->name, vars->name_length);
add_assoc_string(return_value,buf2,buf,1);
}
if (st >= 2 && st != 11) {
if (vars->type != SNMP_ENDOFMIBVIEW &&
vars->type != SNMP_NOSUCHOBJECT && vars->type != SNMP_NOSUCHINSTANCE) {
memmove((char *)name, (char *)vars->name,vars->name_length * sizeof(oid));
name_length = vars->name_length;
keepwalking = 1;
}
}
}
} else {
if (st != 2 || response->errstat != SNMP_ERR_NOSUCHNAME) {
php_error(E_WARNING,"Error in packet.\nReason: %s\n", snmp_errstring(response->errstat));
if (response->errstat == SNMP_ERR_NOSUCHNAME) {
for (count=1, vars = response->variables; vars && count != response->errindex;
vars = vars->next_variable, count++);
if (vars) {
sprint_objid(buf,vars->name, vars->name_length);
}
php_error(E_WARNING,"This name does not exist: %s\n",buf);
}
if (st == 1) {
if ((pdu = snmp_fix_pdu(response, SNMP_MSG_GET)) != NULL) {
goto retry;
}
} else if (st == 11) {
if ((pdu = snmp_fix_pdu(response, SNMP_MSG_SET)) != NULL) {
goto retry;
}
} else if (st >= 2) {
if ((pdu = snmp_fix_pdu(response, SNMP_MSG_GETNEXT)) != NULL) {
goto retry;
}
}
RETURN_FALSE;
}
}
} else if (status == STAT_TIMEOUT) {
php_error(E_WARNING,"No Response from %s\n", (*a1)->value.str.val);
RETURN_FALSE;
} else { /* status == STAT_ERROR */
php_error(E_WARNING,"An error occurred, Quitting...\n");
RETURN_FALSE;
}
if (response) {
snmp_free_pdu(response);
}
} /* keepwalking */
snmp_close(ss);
}
/** {{{ string static public NotSupportedException::className()
*/
PHP_METHOD(NotSupportedException, getName) {
const char *name = "Not Supported";
RETVAL_STRING(name, 1);
return;
}
static void
_dispatch_magick_cmd(INTERNAL_FUNCTION_PARAMETERS, MagickCommand cmd, char *command)
{
zval *arr, **entry;
HashPosition pos;
int argc, i, k = -1;
char *argv[32], **argvp;
zval tval[32], *tvalp;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &arr) == FAILURE) {
return;
}
/* Build command args
*/
argc = zend_hash_num_elements(Z_ARRVAL_P(arr)) + 1;
if (argc > 32) {
argvp = (char **) ecalloc(argc, sizeof(char *));
tvalp = (zval *) ecalloc(argc, sizeof(zval));
} else {
argvp = argv;
tvalp = tval;
}
argvp[0] = command;
for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(arr), &pos), i = 1;
zend_hash_get_current_data_ex(Z_ARRVAL_P(arr), (void **)&entry, &pos) == SUCCESS;
zend_hash_move_forward_ex(Z_ARRVAL_P(arr), &pos), ++i
) {
if (Z_TYPE_PP(entry) == IS_ARRAY || Z_TYPE_PP(entry) == IS_OBJECT) {
continue;
}
if (Z_TYPE_PP(entry) == IS_STRING) {
argvp[i] = Z_STRVAL_PP(entry);
} else {
tvalp[++k] = **entry;
zval_copy_ctor(&tvalp[k]);
convert_to_string(&tvalp[k]);
argvp[i] = Z_STRVAL(tvalp[k]);
}
}
/* Imagick processes
*/
{
MagickBooleanType result;
ImageInfo *ii;
ExceptionInfo *ei;
char *metadata = NULL;
ii = AcquireImageInfo();
ei = AcquireExceptionInfo();
result = (cmd)(ii, argc, argvp, &metadata, ei);
if (ei->reason) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", ei->reason);
}
if (metadata) {
RETVAL_STRING(metadata, 1);
} else {
RETVAL_BOOL(result);
}
if (metadata) {
DestroyString(metadata);
}
DestroyImageInfo(ii);
DestroyExceptionInfo(ei);
}
/* Release resources
*/
while (k != -1) {
zval_dtor(&tvalp[k--]);
}
if (argvp != argv) {
efree(argvp);
efree(tvalp);
}
}
