yp.c

/*
   +----------------------------------------------------------------------+
   | PHP Version 5                                                        |
   +----------------------------------------------------------------------+
   | Copyright (c) 1997-2014 The PHP Group                                |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.php.net/license/3_01.txt                                  |
   | If you did not receive a copy of the PHP license and are unable to   |
   | obtain it through the world-wide-web, please send a note to          |
   | license@php.net so we can mail you a copy immediately.               |
   +----------------------------------------------------------------------+
   | Authors: Stephanie Wehner <_@r4k.net>                                |
   |          Fredrik Ohrn                                                |
   +----------------------------------------------------------------------+
 */
/* $Id$ */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "php.h"
#include "ext/standard/info.h"

#if HAVE_YP

#include "php_yp.h"

#include <rpcsvc/ypclnt.h>

/* {{{ thread safety stuff */

#ifdef ZTS
int yp_globals_id;
#else
PHP_YP_API php_yp_globals yp_globals;
#endif

/* }}} */

ZEND_BEGIN_ARG_INFO_EX(arginfo_yp_none, 0, 0, 0)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_yp_domain_map, 0, 0, 2)
	ZEND_ARG_INFO(0, domain)
	ZEND_ARG_INFO(0, map)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_yp_domain_map_key, 0, 0, 3)
	ZEND_ARG_INFO(0, domain)
	ZEND_ARG_INFO(0, map)
	ZEND_ARG_INFO(0, key)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_yp_domain_map_cb, 0, 0, 3)
	ZEND_ARG_INFO(0, domain)
	ZEND_ARG_INFO(0, map)
	ZEND_ARG_INFO(0, callback)
ZEND_END_ARG_INFO()

ZEND_BEGIN_ARG_INFO_EX(arginfo_yp_errorcode, 0, 0, 1)
	ZEND_ARG_INFO(0, errorcode)
ZEND_END_ARG_INFO()

zend_function_entry yp_functions[] = {
	PHP_FE(yp_get_default_domain, arginfo_yp_none)
	PHP_FE(yp_order,              arginfo_yp_domain_map)
	PHP_FE(yp_master,             arginfo_yp_domain_map)
	PHP_FE(yp_match,              arginfo_yp_domain_map_key)
	PHP_FE(yp_first,              arginfo_yp_domain_map)
	PHP_FE(yp_next,               arginfo_yp_domain_map_key)
	PHP_FE(yp_all,                arginfo_yp_domain_map_cb)
	PHP_FE(yp_cat,                arginfo_yp_domain_map)
	PHP_FE(yp_errno,              arginfo_yp_none)
	PHP_FE(yp_err_string,         arginfo_yp_errorcode)
#ifdef PHP_FE_END
	PHP_FE_END
#else
	{NULL, NULL, NULL}
#endif
};

zend_module_entry yp_module_entry = {
	STANDARD_MODULE_HEADER,
	"yp",
	yp_functions,
	PHP_MINIT(yp),
	NULL,
	PHP_RINIT(yp),
	NULL,
	PHP_MINFO(yp),
	PHP_YP_VERSION,
	STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_YP
ZEND_GET_MODULE(yp)
#endif

/* {{{ proto string yp_get_default_domain(void)
   Returns the domain or false */
PHP_FUNCTION(yp_get_default_domain)
{
	char *outdomain;

	if (ZEND_NUM_ARGS()) {
		WRONG_PARAM_COUNT;
	}

	if((YP(error) = yp_get_default_domain(&outdomain))) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (YP(error)));
		RETURN_FALSE;
	}
	RETVAL_STRING(outdomain,1);
}
/* }}} */

/* {{{ proto int yp_order(string domain, string map)
   Returns the order number or false */
PHP_FUNCTION(yp_order)
{
	char *domain = NULL, *map = NULL;
	int domain_len = 0, map_len = 0;

#if SOLARIS_YP
	unsigned long outval = 0;
#else
	unsigned int outval = 0;
#endif

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss",
				&domain, &domain_len, &map, &map_len) == FAILURE) {
        return;
	}

	if((YP(error) = yp_order(domain, map, &outval))) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (YP(error)));
		RETURN_FALSE;
	}

	RETVAL_LONG(outval);
}
/* }}} */

/* {{{ proto string yp_master(string domain, string map)
   Returns the machine name of the master */
PHP_FUNCTION(yp_master)
{
	char *domain = NULL, *map = NULL, *outname = NULL;
	int domain_len = 0, map_len = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss",
				&domain, &domain_len, &map, &map_len) == FAILURE) {
        return;
	}

	if((YP(error) = yp_master(domain, map, &outname))) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (YP(error)));
		RETURN_FALSE;
	}

	RETVAL_STRING(outname, 1);
}
/* }}} */

/* {{{ proto string yp_match(string domain, string map, string key)
   Returns the matched line or false */
PHP_FUNCTION(yp_match)
{
	char *domain = NULL, *map = NULL, *key = NULL, *outval = NULL;
	int domain_len = 0, map_len = 0, key_len = 0, outvallen = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &domain,
				&domain_len, &map, &map_len, &key, &key_len) == FAILURE) {
        return;
	}

	if((YP(error) = yp_match(domain, map, key, key_len, &outval, &outvallen))) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (YP(error)));
		RETVAL_FALSE;
	} else {
		RETVAL_STRINGL(outval, outvallen, 1);
	}

	if (outval) {
		free(outval);
	}
}
/* }}} */

/* {{{ proto array yp_first(string domain, string map)
   Returns the first key as array with $var[$key] and the the line as the value */
PHP_FUNCTION(yp_first)
{
	char *domain = NULL, *map = NULL, *outkey = NULL, *outval = NULL;
	int domain_len = 0, map_len = 0, outkey_len, outval_len;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss",
				&domain, &domain_len, &map, &map_len) == FAILURE) {
        return;
	}

	if((YP(error) = yp_first(domain, map, &outkey, &outkey_len, &outval, &outval_len))) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (YP(error)));
		RETVAL_FALSE;
	} else {
		array_init(return_value);
		add_assoc_stringl_ex(return_value, outkey, outkey_len + 1, outval, outval_len, 1);
	}

	if (outval) {
		free(outval);
	}
}
/* }}} */

/* {{{ proto array yp_next(string domain, string map, string key)
   Returns an array with $var[$key] and the the line as the value */
PHP_FUNCTION(yp_next)
{
	char *domain = NULL, *map = NULL, *key = NULL;
	int domain_len = 0, map_len = 0, key_len = 0;
	char *outkey = NULL, *outval = NULL;
	int outkey_len = 0, outval_len = 0;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &domain,
				&domain_len, &map, &map_len, &key, &key_len) == FAILURE) {
        return;
	}

	if((YP(error) = yp_next(domain, map, key, key_len, &outkey, &outkey_len, &outval, &outval_len))) {
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (YP(error)));
		RETVAL_FALSE;
	} else {
		array_init(return_value);
		add_assoc_stringl_ex(return_value, outkey, outkey_len + 1, outval, outval_len, 1);
    }

	if (outval) {
		free(outval);
	}
}
/* }}} */

/* {{{ php_foreach_all
 */
static int php_foreach_all (int instatus, char *inkey, int inkeylen, char *inval, int invallen, char *indata)
{
	int is_stop = 0;
	zval *args;
	zval *retval;
	TSRMLS_FETCH();

	MAKE_STD_ZVAL(args);
	array_init(args);
	add_index_long(args, 0, instatus);
	add_index_stringl(args, 1, inkey, inkeylen, 1);
	add_index_stringl(args, 2, inval, invallen, 1);

	php_yp_all_callback *cb = (php_yp_all_callback *) indata;
	zend_fcall_info_args(&cb->fci, args TSRMLS_CC);
	zend_fcall_info_call(&cb->fci, &cb->fcc, &retval, args TSRMLS_CC);
	zend_fcall_info_args_clear(&cb->fci, 1);

	if (retval) {
		is_stop = zval_is_true(retval);
		zval_ptr_dtor(&retval);
	}

	return is_stop;
}
/* }}} */

/* {{{ proto bool yp_all(string domain, string map, string callback)
   Traverse the map and call a function on each entry */
PHP_FUNCTION(yp_all)
{
	char *domain = NULL, *map = NULL;
	int domain_len = 0, map_len = 0;
	php_yp_all_callback *foreach_cb = emalloc(sizeof(php_yp_all_callback));

	struct ypall_callback callback;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssf",
				&domain, &domain_len, &map, &map_len,
				&foreach_cb->fci, &foreach_cb->fcc) == FAILURE) {
        return;
	}

	callback.foreach = php_foreach_all;
	callback.data = (void *)foreach_cb;

	yp_all(domain, map, &callback);

	efree(foreach_cb);
	RETURN_FALSE;
}
/* }}} */

/* {{{ php_foreach_cat
 */
static int php_foreach_cat (int instatus, char *inkey, int inkeylen, char *inval, int invallen, char *indata)
{
	int err;

	err = ypprot_err (instatus);

	if (!err)
	{
		if (inkeylen) {
			char *key = emalloc(inkeylen+1);
			strlcpy(key, inkey, inkeylen+1);
			add_assoc_stringl_ex((zval *) indata, key, inkeylen+1, inval, invallen, 1);
			efree(key);
		}

		return 0;
	}

	if (err != YPERR_NOMORE)
	{
		TSRMLS_FETCH();

		YP(error) = err;
		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", yperr_string (err));
	}

	return 0;
}
/* }}} */

/* {{{ proto array yp_cat(string domain, string map)
   Return an array containing the entire map */
PHP_FUNCTION(yp_cat)
{
	char *domain = NULL, *map = NULL;
	int domain_len = 0, map_len = 0;
	struct ypall_callback callback;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss",
				&domain, &domain_len, &map, &map_len) == FAILURE) {
        return;
	}

	array_init(return_value);

	callback.foreach = php_foreach_cat;
	callback.data = (char *) return_value;

	yp_all(domain, map, &callback);
}
/* }}} */

/* {{{ proto int yp_errno()
   Returns the error code from the last call or 0 if no error occured */
PHP_FUNCTION(yp_errno)
{
	if((ZEND_NUM_ARGS() != 0)) {
		WRONG_PARAM_COUNT;
	}

	RETURN_LONG (YP(error));
}
/* }}} */

/* {{{ proto string yp_err_string(int errorcode)
   Returns the corresponding error string for the given error code */
PHP_FUNCTION(yp_err_string)
{
	long errcode = 0;
	const char *string = NULL;

	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &errcode) == FAILURE) {
        return;
	}

	if((string = yperr_string(errcode)) == NULL) {
		RETURN_FALSE;
	}

	RETVAL_STRING(string, 1);
}
/* }}} */

/* {{{ PHP_MINIT_FUNCTION
 */
PHP_MINIT_FUNCTION(yp)
{
#ifdef ZTS
	ts_allocate_id(&yp_globals_id, sizeof(php_yp_globals), NULL, NULL);
#endif

	REGISTER_LONG_CONSTANT("YPERR_ACCESS", YPERR_ACCESS, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_BADARGS", YPERR_BADARGS, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_BADDB", YPERR_BADDB, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_BUSY", YPERR_BUSY, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_DOMAIN", YPERR_DOMAIN, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_KEY", YPERR_KEY, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_MAP", YPERR_MAP, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_NODOM", YPERR_NODOM, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_NOMORE", YPERR_NOMORE, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_PMAP", YPERR_PMAP, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_RESRC", YPERR_RESRC, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_RPC", YPERR_RPC, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_YPBIND", YPERR_YPBIND, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_YPERR", YPERR_YPERR, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_YPSERV", YPERR_YPSERV, CONST_CS | CONST_PERSISTENT);
	REGISTER_LONG_CONSTANT("YPERR_VERS", YPERR_VERS, CONST_CS | CONST_PERSISTENT);

	return SUCCESS;
}
/* }}} */

PHP_RINIT_FUNCTION(yp)
{
	YP(error) = 0;
	
	return SUCCESS;
}

PHP_MINFO_FUNCTION(yp)
{
	php_info_print_table_start();
	php_info_print_table_header(2, "YP Support", "enabled");
	php_info_print_table_row(2, "Version", PHP_YP_VERSION);
	php_info_print_table_end();
}
#endif /* HAVE_YP */

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * End:
 * vim600: sw=4 ts=4 fdm=marker
 * vim<600: sw=4 ts=4
 */