自学教程：C++ zbx_snprintf_alloc函数代码示例

static void	DBdrop_index_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,		const char *table_name, const char *index_name){	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "drop index %s", index_name);#ifdef HAVE_MYSQL	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, " on %s", table_name);#endif}

/****************************************************************************** *                                                                            * * Function: op_groups_del                                                    * *                                                                            * * Purpose: delete groups from discovered host                                * *                                                                            * * Parameters: event    - [IN] event data                                     * *             groupids - [IN] IDs of groups to delete                        * *                                                                            * * Author: Alexei Vladishev                                                   * *                                                                            * ******************************************************************************/void	op_groups_del(const DB_EVENT *event, zbx_vector_uint64_t *groupids){	const char	*__function_name = "op_groups_del";	DB_RESULT	result;	zbx_uint64_t	hostid;	char		*sql = NULL;	size_t		sql_alloc = 256, sql_offset = 0;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (event->source != EVENT_SOURCE_DISCOVERY)		return;	if (event->object != EVENT_OBJECT_DHOST && event->object != EVENT_OBJECT_DSERVICE)		return;	if (0 == (hostid = select_discovered_host(event)))		return;	sql = zbx_malloc(sql, sql_alloc);	/* make sure host belongs to at least one hostgroup */	zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,			"select groupid"			" from hosts_groups"			" where hostid=" ZBX_FS_UI64				" and not",			hostid);	DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "groupid", groupids->values, groupids->values_num);	result = DBselectN(sql, 1);	if (NULL == DBfetch(result))	{		zabbix_log(LOG_LEVEL_WARNING, "cannot remove host /"%s/" from all host groups:"				" it must belong to at least one", zbx_host_string(hostid));	}	else	{		sql_offset = 0;		zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,				"delete from hosts_groups"				" where hostid=" ZBX_FS_UI64					" and",				hostid);		DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "groupid", groupids->values, groupids->values_num);		DBexecute("%s", sql);	}	DBfree_result(result);	zbx_free(sql);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

static void	DBmodify_field_type_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,		const char *table_name, const ZBX_FIELD *field){	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter table %s" ZBX_DB_ALTER_COLUMN " ", table_name);#ifdef HAVE_MYSQL	DBfield_definition_string(sql, sql_alloc, sql_offset, field);#else	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s" ZBX_DB_SET_TYPE " ", field->name);	DBfield_type_string(sql, sql_alloc, sql_offset, field);#endif}

static void	DBrename_field_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,		const char *table_name, const char *field_name, const ZBX_FIELD *field){	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter table %s ", table_name);#ifdef HAVE_MYSQL	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "change column %s ", field_name);	DBfield_definition_string(sql, sql_alloc, sql_offset, field);#else	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "rename column %s to %s", field_name, field->name);#endif}

static void	DBset_default_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,		const char *table_name, const ZBX_FIELD *field){	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter table %s" ZBX_DB_ALTER_COLUMN " ", table_name);#if defined(HAVE_MYSQL)	DBfield_definition_string(sql, sql_alloc, sql_offset, field);#elif defined(HAVE_ORACLE)	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s default '%s'", field->name, field->default_value);#else	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s set default '%s'", field->name, field->default_value);#endif}

static void	DBdrop_not_null_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,		const char *table_name, const ZBX_FIELD *field){	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter table %s" ZBX_DB_ALTER_COLUMN " ", table_name);#if defined(HAVE_MYSQL)	DBfield_definition_string(sql, sql_alloc, sql_offset, field);#elif defined(HAVE_ORACLE)	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s null", field->name);#else	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s drop not null", field->name);#endif}

static void	DBrename_index_sql(char **sql, size_t *sql_alloc, size_t *sql_offset, const char *table_name,		const char *old_name, const char *new_name, const char *fields, int unique){#if defined(HAVE_IBM_DB2)	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "rename index %s to %s", old_name, new_name);#elif defined(HAVE_MYSQL)	DBcreate_index_sql(sql, sql_alloc, sql_offset, table_name, new_name, fields, unique);	zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ";/n");	DBdrop_index_sql(sql, sql_alloc, sql_offset, table_name, old_name);	zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ";/n");#elif defined(HAVE_ORACLE) || defined(HAVE_POSTGRESQL)	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "alter index %s rename to %s", old_name, new_name);#endif}

static void	DBfield_type_string(char **sql, size_t *sql_alloc, size_t *sql_offset, const ZBX_FIELD *field){	switch (field->type)	{		case ZBX_TYPE_ID:			zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_ID_STR);			break;		case ZBX_TYPE_INT:			zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_INT_STR);			break;		case ZBX_TYPE_CHAR:			zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s(%hu)", ZBX_TYPE_CHAR_STR, field->length);			break;		case ZBX_TYPE_FLOAT:			zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_FLOAT_STR);			break;		case ZBX_TYPE_UINT:			zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_UINT_STR);			break;		case ZBX_TYPE_SHORTTEXT:			zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_SHORTTEXT_STR);			break;		case ZBX_TYPE_TEXT:			zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ZBX_TYPE_TEXT_STR);			break;		default:			assert(0);	}}

static void	DBfield_definition_string(char **sql, size_t *sql_alloc, size_t *sql_offset, const ZBX_FIELD *field){	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s ", field->name);	DBfield_type_string(sql, sql_alloc, sql_offset, field);	if (NULL != field->default_value)	{		char	*default_value_esc;#if defined(HAVE_MYSQL)		switch (field->type)		{			case ZBX_TYPE_BLOB:			case ZBX_TYPE_TEXT:			case ZBX_TYPE_SHORTTEXT:			case ZBX_TYPE_LONGTEXT:				/* MySQL: BLOB and TEXT columns cannot be assigned a default value */				break;			default:#endif				default_value_esc = DBdyn_escape_string(field->default_value);				zbx_snprintf_alloc(sql, sql_alloc, sql_offset, " default '%s'", default_value_esc);				zbx_free(default_value_esc);#if defined(HAVE_MYSQL)		}#endif	}	if (0 != (field->flags & ZBX_NOTNULL))	{#if defined(HAVE_ORACLE)		switch (field->type)		{			case ZBX_TYPE_INT:			case ZBX_TYPE_FLOAT:			case ZBX_TYPE_BLOB:			case ZBX_TYPE_UINT:			case ZBX_TYPE_ID:				zbx_strcpy_alloc(sql, sql_alloc, sql_offset, " not null");				break;			default:	/* ZBX_TYPE_CHAR, ZBX_TYPE_TEXT, ZBX_TYPE_SHORTTEXT or ZBX_TYPE_LONGTEXT */				/* nothing to do */;		}#else		zbx_strcpy_alloc(sql, sql_alloc, sql_offset, " not null");#endif	}}

static void	DBcreate_table_sql(char **sql, size_t *sql_alloc, size_t *sql_offset, const ZBX_TABLE *table){	int	i;	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "create table %s (/n", table->table);	for (i = 0; NULL != table->fields[i].name; i++)	{		if (0 != i)			zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ",/n");		DBfield_definition_string(sql, sql_alloc, sql_offset, &table->fields[i]);	}	if ('/0' != *table->recid)		zbx_snprintf_alloc(sql, sql_alloc, sql_offset, ",/nprimary key (%s)", table->recid);	zbx_strcpy_alloc(sql, sql_alloc, sql_offset, "/n)" ZBX_DB_TABLE_OPTIONS);}

/********************************************************************************* *                                                                               * * Function: db_read_values_by_time                                              * *                                                                               * * Purpose: reads item history data from database                                * *                                                                               * * Parameters:  itemid        - [IN] the itemid                                  * *              value_type    - [IN] the value type (see ITEM_VALUE_TYPE_* defs) * *              values        - [OUT] the item history data values               * *              seconds       - [IN] the time period to read                     * *              end_timestamp - [IN] the value timestamp to start reading with   * *                                                                               * * Return value: SUCCEED - the history data were read successfully               * *               FAIL - otherwise                                                * *                                                                               * * Comments: This function reads all values with timestamps in range:            * *             end_timestamp - seconds < <value timestamp> <= end_timestamp      * *                                                                               * *********************************************************************************/static int	db_read_values_by_time(zbx_uint64_t itemid, int value_type, zbx_vector_history_record_t *values,		int seconds, int end_timestamp){	char			*sql = NULL;	size_t	 		sql_alloc = 0, sql_offset = 0;	DB_RESULT		result;	DB_ROW			row;	zbx_vc_history_table_t	*table = &vc_history_tables[value_type];	zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,			"select clock,ns,%s"			" from %s"			" where itemid=" ZBX_FS_UI64,			table->fields, table->name, itemid);	if (1 == seconds)	{		zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, " and clock=%d", end_timestamp);	}	else	{		zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, " and clock>%d and clock<=%d",				end_timestamp - seconds, end_timestamp);	}	result = DBselect("%s", sql);	zbx_free(sql);	if (NULL == result)		goto out;	while (NULL != (row = DBfetch(result)))	{		zbx_history_record_t	value;		value.timestamp.sec = atoi(row[0]);		value.timestamp.ns = atoi(row[1]);		table->rtov(&value.value, row + 2);		zbx_vector_history_record_append_ptr(values, &value);	}	DBfree_result(result);out:	return SUCCEED;}

static void	DBcreate_index_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,		const char *table_name, const char *index_name, const char *fields, int unique){	zbx_strcpy_alloc(sql, sql_alloc, sql_offset, "create");	if (0 != unique)		zbx_strcpy_alloc(sql, sql_alloc, sql_offset, " unique");	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, " index %s on %s (%s)", index_name, table_name, fields);}

static void	DBadd_foreign_key_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,		const char *table_name, int id, const ZBX_FIELD *field){	zbx_snprintf_alloc(sql, sql_alloc, sql_offset,			"alter table %s add constraint c_%s_%d foreign key (%s) references %s (%s)",			table_name, table_name, id, field->name, field->fk_table, field->fk_field);	if (0 != (field->fk_flags & ZBX_FK_CASCADE_DELETE))		zbx_strcpy_alloc(sql, sql_alloc, sql_offset, " on delete cascade");}

static char	*lld_expression_expand(const char *expression, zbx_vector_ptr_t *functions){	const char		*__function_name = "lld_expression_expand";	size_t			l, r;	int			i;	zbx_uint64_t		index;	zbx_lld_function_t	*function;	char			*buffer = NULL;	size_t			buffer_alloc = 64, buffer_offset = 0;	zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __function_name, expression);	buffer = zbx_malloc(buffer, buffer_alloc);	*buffer = '/0';	for (l = 0; '/0' != expression[l]; l++)	{		zbx_chrcpy_alloc(&buffer, &buffer_alloc, &buffer_offset, expression[l]);		if ('{' != expression[l])			continue;		for (r = l + 1; '/0' != expression[r] && '}' != expression[r]; r++)			;		if ('}' != expression[r])			continue;		/* ... > 0 | {1} + ... */		/*           l r       */		if (SUCCEED != is_uint64_n(expression + l + 1, r - l - 1, &index))			continue;		for (i = 0; i < functions->values_num; i++)		{			function = (zbx_lld_function_t *)functions->values[i];			if (function->index != index)				continue;			zbx_snprintf_alloc(&buffer, &buffer_alloc, &buffer_offset, ZBX_FS_UI64 ":%s(%s)",					function->itemid, function->function, function->parameter);			break;		}		l = r - 1;	}	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():'%s'", __function_name, buffer);	return buffer;}

static void	begin_history_sql(char **sql, size_t *sql_alloc, size_t *sql_offset, const ZBX_TABLE *table){	int	f;	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "insert into %s (", table->table);	if (0 != (table->flags & ZBX_HISTORY_SYNC))		zbx_strcpy_alloc(sql, sql_alloc, sql_offset, "nodeid,");	for (f = 0; table->fields[f].name != 0; f++)	{		if (0 != (table->flags & ZBX_HISTORY_SYNC) && 0 == (table->fields[f].flags & ZBX_HISTORY_SYNC))			continue;		zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "%s,", table->fields[f].name);	}	(*sql_offset)--;	zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ") values ");}

static int	calcitem_parse_expression(DC_ITEM *dc_item, expression_t *exp,		char *error, int max_error_len){	const char	*__function_name = "calcitem_parse_expression";	char		*e, *f, *func = NULL, *params = NULL;	int		functionid, exp_alloc = 128, exp_offset = 0, ret;	zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __function_name, dc_item->params_orig);	assert(dc_item);	assert(exp);	exp->exp = zbx_malloc(exp->exp, exp_alloc);	for (e = dc_item->params_orig; '/0' != *e; e++)	{		if (NULL != strchr(" /t/r/n", *e))			continue;		f = e;		if (FAIL == parse_function(&e, &func, &params))		{			e = f;			calcitem_exp_addchr(&exp->exp, &exp_alloc, &exp_offset, 128, *f);			continue;		}		else			e--;		functionid = calcitem_add_function(exp, func, params);		zabbix_log(LOG_LEVEL_DEBUG, "%s() functionid:%d function:'%s(%s)'",				__function_name, functionid, func, params);		func = NULL;		params = NULL;		zbx_snprintf_alloc(&exp->exp, &exp_alloc, &exp_offset, 16, "{%d}", functionid);	}	calcitem_exp_addchr(&exp->exp, &exp_alloc, &exp_offset, 1, '/0');	zabbix_log(LOG_LEVEL_DEBUG, "%s() expression:'%s'", __function_name, exp->exp);	if (FAIL == (ret = substitute_simple_macros(NULL, NULL, NULL, dc_item, NULL,				&exp->exp, MACRO_TYPE_ITEM_EXPRESSION, error, max_error_len)))		ret = NOTSUPPORTED;	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));	return ret;}

/****************************************************************************** *                                                                            * * Function: log_host_maintenance_update                                      * *                                                                            * * Purpose: log host maintenance changes                                      * *                                                                            * ******************************************************************************/static void	log_host_maintenance_update(const zbx_host_maintenance_diff_t* diff){	char	*msg = NULL;	size_t	msg_alloc = 0, msg_offset = 0;	int	maintenance_off = 0;	if (0 != (diff->flags & ZBX_FLAG_HOST_MAINTENANCE_UPDATE_MAINTENANCE_STATUS))	{		if (HOST_MAINTENANCE_STATUS_ON == diff->maintenance_status)		{			zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, "putting host (" ZBX_FS_UI64 ") into",					diff->hostid);		}		else		{			maintenance_off = 1;			zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, "taking host (" ZBX_FS_UI64 ") out of",				diff->hostid);		}	}	else		zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, "changing host (" ZBX_FS_UI64 ")", diff->hostid);	zbx_strcpy_alloc(&msg, &msg_alloc, &msg_offset, " maintenance");	if (0 != (diff->flags & ZBX_FLAG_HOST_MAINTENANCE_UPDATE_MAINTENANCEID) && 0 != diff->maintenanceid)		zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, "(" ZBX_FS_UI64 ")", diff->maintenanceid);	if (0 != (diff->flags & ZBX_FLAG_HOST_MAINTENANCE_UPDATE_MAINTENANCE_TYPE) && 0 == maintenance_off)	{		const char	*desription[] = {"with data collection", "without data collection"};		zbx_snprintf_alloc(&msg, &msg_alloc, &msg_offset, " %s", desription[diff->maintenance_type]);	}	zabbix_log(LOG_LEVEL_DEBUG, "%s", msg);	zbx_free(msg);}

/****************************************************************************** *                                                                            * * Function: str_base64_encode_rfc2047                                        * *                                                                            * * Purpose: Encode a string into a base64 string as required by rfc2047.      * *          Used for encoding e-mail headers.                                 * *                                                                            * * Parameters: src      - [IN] a null-terminated UTF-8 string to encode       * *             p_base64 - [OUT] a pointer to the encoded string               * *                                                                            * * Comments: Based on the patch submitted by                                  * *           Jairo Eduardo Lopez Fuentes Nacarino                             * *                                                                            * ******************************************************************************/static void	str_base64_encode_rfc2047(const char *src, char **p_base64){	const char	*p0;			/* pointer in src to start encoding from */	const char	*p1;			/* pointer in src: 1st byte of UTF-8 character */	size_t		c_len;			/* length of UTF-8 character sequence */	size_t		p_base64_alloc;		/* allocated memory size for subject */	size_t		p_base64_offset = 0;	/* offset for writing into subject */	assert(src);	assert(NULL == *p_base64);		/* do not accept already allocated memory */	p_base64_alloc = ZBX_EMAIL_B64_MAXWORD_RFC2047 + sizeof(ZBX_EMAIL_ENCODED_WORD_SEPARATOR);	*p_base64 = zbx_malloc(NULL, p_base64_alloc);	**p_base64 = '/0';	for (p0 = src; '/0' != *p0; p0 = p1)	{		/* Max length of line is 76 characters (without line separator). */		/* Max length of "encoded-word" is 75 characters (without word separator). */		/* 3 characters are taken by word separator "<CR><LF><Space>" which also includes the line separator. */		/* 12 characters are taken by header "=?UTF-8?B?" and trailer "?=". */		/* So, one "encoded-word" can hold up to 63 characters of Base64-encoded string. */		/* Encoding 45 bytes produces a 61 byte long Base64-encoded string which meets the limit. */		/* Encoding 46 bytes produces a 65 byte long Base64-encoded string which exceeds the limit. */		for (p1 = p0, c_len = 0; '/0' != *p1; p1 += c_len)		{			/* an invalid UTF-8 character or length of a string more than 45 bytes */			if (0 == (c_len = zbx_utf8_char_len(p1)) || 45 < p1 - p0 + c_len)				break;		}		if (0 < p1 - p0)		{			/* 12 characters are taken by header "=?UTF-8?B?" and trailer "?=" plus '/0' */			char	b64_buf[ZBX_EMAIL_B64_MAXWORD_RFC2047 - 12 + 1];			str_base64_encode(p0, b64_buf, p1 - p0);			if (0 != p_base64_offset)	/* not the first "encoded-word" ? */			{				zbx_strcpy_alloc(p_base64, &p_base64_alloc, &p_base64_offset,						ZBX_EMAIL_ENCODED_WORD_SEPARATOR);			}			zbx_snprintf_alloc(p_base64, &p_base64_alloc, &p_base64_offset, "=?UTF-8?B?%s?=", b64_buf);		}		else			break;	}}

static size_t	WRITEFUNCTION2(void *ptr, size_t size, size_t nmemb, void *userdata){	size_t	r_size = size * nmemb;	/* first piece of data */	if (NULL == page.data)	{		page.allocated = MAX(8096, r_size);		page.offset = 0;		page.data = zbx_malloc(page.data, page.allocated);	}	zbx_snprintf_alloc(&page.data, &page.allocated, &page.offset, MAX(8096, r_size), "%s", ptr);	return r_size;}

/****************************************************************************** *                                                                            * * Function: tm_process_check_now                                             * *                                                                            * * Purpose: process check now tasks for item rescheduling                     * *                                                                            * * Return value: The number of successfully processed tasks                   * *                                                                            * ******************************************************************************/static int	tm_process_check_now(zbx_vector_uint64_t *taskids){	DB_ROW			row;	DB_RESULT		result;	int			processed_num;	char			*sql = NULL;	size_t			sql_alloc = 0, sql_offset = 0;	zbx_vector_uint64_t	itemids;	zbx_uint64_t		itemid;	zabbix_log(LOG_LEVEL_DEBUG, "In %s() tasks_num:%d", __func__, taskids->values_num);	zbx_vector_uint64_create(&itemids);	zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, "select itemid from task_check_now where");	DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "taskid", taskids->values, taskids->values_num);	result = DBselect("%s", sql);	while (NULL != (row = DBfetch(result)))	{		ZBX_STR2UINT64(itemid, row[0]);		zbx_vector_uint64_append(&itemids, itemid);	}	DBfree_result(result);	if (0 != (processed_num = itemids.values_num))		zbx_dc_reschedule_items(&itemids, time(NULL), NULL);	if (0 != taskids->values_num)	{		sql_offset = 0;		zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "update task set status=%d where",				ZBX_TM_STATUS_DONE);		DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "taskid", taskids->values, taskids->values_num);		DBexecute("%s", sql);	}	zbx_free(sql);	zbx_vector_uint64_destroy(&itemids);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s() processed:%d", __func__, processed_num);	return processed_num;}

static void	collect_args(char **argv, int argc, char **args, size_t *args_alloc){	int	i;	size_t	args_offset = 0;	if (0 == *args_alloc)	{		*args_alloc = ARGS_START_SIZE;		*args = zbx_malloc(*args, *args_alloc);	}	for (i = 0; i < argc; i++)		zbx_snprintf_alloc(args, args_alloc, &args_offset, "%s ", argv[i]);	if (0 != args_offset)		args_offset--; /* ' ' */	(*args)[args_offset] = '/0';}

static void	make_delete_sql(char **sql, size_t *sql_alloc, size_t *sql_offset,		const ZBX_TABLE *table, zbx_uint64_t *ids, int *ids_num){	if (NULL == table)		return;	if (0 == *ids_num)		return;	zbx_snprintf_alloc(sql, sql_alloc, sql_offset, "delete from %s where", table->table);	DBadd_condition_alloc(sql, sql_alloc, sql_offset, table->recid, ids, *ids_num);	zbx_strcpy_alloc(sql, sql_alloc, sql_offset, ";/n");	DBexecute_overflowed_sql(sql, sql_alloc, sql_offset);	*ids_num = 0;}

static void	collect_args(char **argv, int argc, char **args, size_t *args_alloc){	int	i, args_offset, len;	if (0 == *args_alloc) {		*args_alloc = ARGS_START_SIZE;		*args = zbx_malloc(*args, *args_alloc);	}	args_offset = 0;	for (i = 0; i < argc; i ++ ) {		len = (int)(strlen(argv[i]) + 2/* ' '+'/0' */);		zbx_snprintf_alloc(args, (int *)args_alloc, &args_offset, len, "%s ", argv[i]);	}	if (0 != args_offset)		args_offset--; /* ' ' */	(*args)[args_offset] = '/0';}

/****************************************************************************** *                                                                            * * Function: save_events                                                      * *                                                                            * * Purpose: flushes the events into a database                                * *                                                                            * ******************************************************************************/static void	save_events(){	char		*sql = NULL;	size_t		sql_alloc = 2 * ZBX_KIBIBYTE, sql_offset = 0, i;	const char	*ins_event_sql = "insert into events (eventid,source,object,objectid,clock,ns,value) values ";	sql = zbx_malloc(sql, sql_alloc);	DBbegin_multiple_update(&sql, &sql_alloc, &sql_offset);#ifdef HAVE_MULTIROW_INSERT	zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ins_event_sql);#endif	for (i = 0; i < events_num; i++)	{		if (0 == events[i].eventid)			events[i].eventid = DBget_maxid("events");#ifndef HAVE_MULTIROW_INSERT		zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ins_event_sql);#endif		zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,			"(" ZBX_FS_UI64 ",%d,%d," ZBX_FS_UI64 ",%d,%d,%d)" ZBX_ROW_DL,			events[i].eventid, events[i].source, events[i].object, events[i].objectid, events[i].clock,			events[i].ns, events[i].value);	}#ifdef HAVE_MULTIROW_INSERT	sql_offset--;	zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, ";/n");#endif	DBend_multiple_update(&sql, &sql_alloc, &sql_offset);	DBexecute("%s", sql);	zbx_free(sql);}

/****************************************************************************** *                                                                            * * Function: DMget_config_data                                                * *                                                                            * * Purpose: get configuration changes to required node                        * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value: SUCCESS - processed successfully                             * *               FAIL - an error occurred                                     * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/char	*DMget_config_data(int nodeid, unsigned char dest_nodetype){	const char	*__function_name = "DMget_config_data";	char		*ptbls = NULL;	/* list of processed tables */	size_t		ptbls_alloc = ZBX_KIBIBYTE, ptbls_offset = 0;	char		*data = NULL;	size_t		data_alloc = ZBX_KIBIBYTE, data_offset = 0;	int		t;	zabbix_log(LOG_LEVEL_DEBUG, "In %s() node:%d dest_nodetype:%s", __function_name,			nodeid, zbx_nodetype_string(dest_nodetype));	ptbls = zbx_malloc(ptbls, ptbls_alloc);	data = zbx_malloc(data, data_alloc);	*ptbls = '/0';	zbx_snprintf_alloc(&data, &data_alloc, &data_offset, "Data%c%d%c%d",			ZBX_DM_DELIMITER, CONFIG_NODEID, ZBX_DM_DELIMITER, nodeid);	for (t = 0; NULL != tables[t].table; t++)	{		if (0 == (tables[t].flags & ZBX_SYNC))			continue;		DMget_table_data(nodeid, dest_nodetype, &tables[t], &data, &data_alloc, &data_offset,				&ptbls, &ptbls_alloc, &ptbls_offset);	}	zbx_free(ptbls);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);	return data;}

static int	zbx_check_user_parameter(const char *param, char *error, int max_error_len){	const char	suppressed_chars[] = "//'/"`*?[]{}~$!&;()<>|#@/n", *c;	char		*buf = NULL;	size_t		buf_alloc = 128, buf_offset = 0;	if (0 != CONFIG_UNSAFE_USER_PARAMETERS)		return SUCCEED;	for (c = suppressed_chars; '/0' != *c; c++)	{		if (NULL == strchr(param, *c))			continue;		buf = zbx_malloc(buf, buf_alloc);		for (c = suppressed_chars; '/0' != *c; c++)		{			if (c != suppressed_chars)				zbx_strcpy_alloc(&buf, &buf_alloc, &buf_offset, ", ");			if (0 != isprint(*c))				zbx_chrcpy_alloc(&buf, &buf_alloc, &buf_offset, *c);			else				zbx_snprintf_alloc(&buf, &buf_alloc, &buf_offset, "0x%02x", *c);		}		zbx_snprintf(error, max_error_len, "special characters /"%s/" are not allowed in the parameters", buf);		zbx_free(buf);		return FAIL;	}	return SUCCEED;}

/****************************************************************************** *                                                                            * * Function: evaluate_aggregate                                               * *                                                                            * * Parameters: item      - [IN] aggregated item                               * *             grp_func  - [IN] one of ZBX_GRP_FUNC_*                         * *             groups    - [IN] list of comma-separated host groups           * *             itemkey   - [IN] item key to aggregate                         * *             item_func - [IN] one of ZBX_DB_GET_HIST_*                      * *             param     - [IN] item_func parameter (optional)                * *                                                                            * * Return value: SUCCEED - aggregate item evaluated successfully              * *               FAIL - otherwise                                             * *                                                                            * ******************************************************************************/static int	evaluate_aggregate(DC_ITEM *item, AGENT_RESULT *res, int grp_func, const char *groups,                               const char *itemkey, int item_func, const char *param){    const char		*__function_name = "evaluate_aggregate";    char			*sql = NULL;    size_t			sql_alloc = 1024, sql_offset = 0;    zbx_uint64_t		itemid;    zbx_vector_uint64_t	itemids;    DB_RESULT		result;    DB_ROW			row;    unsigned char		value_type;    history_value_t		value;    int			num = 0, ret = FAIL;    zabbix_log(LOG_LEVEL_DEBUG, "In %s() grp_func:%d groups:'%s' itemkey:'%s' item_func:%d param:'%s'",               __function_name, grp_func, groups, itemkey, item_func, param);    memset(&value, 0, sizeof(value));    zbx_vector_uint64_create(&itemids);    aggregate_get_items(&itemids, groups, itemkey);    if (0 == itemids.values_num)    {        SET_MSG_RESULT(res, zbx_dsprintf(NULL, "No items for key [%s] in group(s) [%s]", itemkey, groups));        goto clean;    }    sql = zbx_malloc(sql, sql_alloc);    if (ZBX_DB_GET_HIST_VALUE == item_func)    {        zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,                           "select value_type,lastvalue"                           " from items"                           " where lastvalue is not null"                           " and value_type in (%d,%d)"                           " and",                           ITEM_VALUE_TYPE_FLOAT, ITEM_VALUE_TYPE_UINT64);        DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "itemid", itemids.values, itemids.values_num);        result = DBselect("%s", sql);        while (NULL != (row = DBfetch(result)))        {            value_type = (unsigned char)atoi(row[0]);            evaluate_one(item, &value, &num, grp_func, row[1], value_type);        }        DBfree_result(result);    }    else    {        int		clock_from;        unsigned int	period;        char		**h_value;        if (FAIL == is_uint_suffix(param, &period))        {            SET_MSG_RESULT(res, zbx_strdup(NULL, "Invalid fourth parameter"));            goto clean;        }        clock_from = time(NULL) - period;        zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,                           "select itemid,value_type"                           " from items"                           " where value_type in (%d,%d)"                           " and",                           ITEM_VALUE_TYPE_FLOAT, ITEM_VALUE_TYPE_UINT64);        DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "itemid", itemids.values, itemids.values_num);        result = DBselect("%s", sql);        while (NULL != (row = DBfetch(result)))        {            ZBX_STR2UINT64(itemid, row[0]);            value_type = (unsigned char)atoi(row[1]);            h_value = DBget_history(itemid, value_type, item_func, clock_from, 0, NULL, NULL, 0);            if (NULL != h_value[0])                evaluate_one(item, &value, &num, grp_func, h_value[0], value_type);//.........这里部分代码省略.........

/****************************************************************************** *                                                                            * * Function: aggregate_get_items                                              * *                                                                            * * Purpose: get array of items specified by key for selected groups           * *                                                                            * * Parameters: itemids - [OUT] list of item ids                               * *             groups  - [IN] list of comma-separated host groups             * *             itemkey - [IN] item key to aggregate                           * *                                                                            * ******************************************************************************/static void	aggregate_get_items(zbx_vector_uint64_t *itemids, const char *groups, const char *itemkey){    const char	*__function_name = "aggregate_get_items";    char		*group, *esc;    DB_RESULT	result;    DB_ROW		row;    zbx_uint64_t	itemid;    char		*sql = NULL;    size_t		sql_alloc = ZBX_KIBIBYTE, sql_offset = 0;    int		num, n;    zabbix_log(LOG_LEVEL_DEBUG, "In %s() groups:'%s' itemkey:'%s'", __function_name, groups, itemkey);    sql = zbx_malloc(sql, sql_alloc);    esc = DBdyn_escape_string(itemkey);    zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,                       "select distinct i.itemid"                       " from items i,hosts h,hosts_groups hg,groups g"                       " where i.hostid=h.hostid"                       " and h.hostid=hg.hostid"                       " and hg.groupid=g.groupid"                       " and i.key_='%s'"                       " and i.status=%d"                       " and h.status=%d",                       esc, ITEM_STATUS_ACTIVE, HOST_STATUS_MONITORED);    zbx_free(esc);    num = num_param(groups);    zbx_strcpy_alloc(&sql, &sql_alloc, &sql_offset, " and g.name in (");    for (n = 1; n <= num; n++)    {        if (NULL == (group = get_param_dyn(groups, n)))            continue;        esc = DBdyn_escape_string(group);        zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "'%s'", esc);        if (n != num)            zbx_chrcpy_alloc(&sql, &sql_alloc, &sql_offset, ',');        zbx_free(esc);        zbx_free(group);    }    zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, ")" DB_NODE, DBnode_local("h.hostid"));    result = DBselect("%s", sql);    zbx_free(sql);    while (NULL != (row = DBfetch(result)))    {        ZBX_STR2UINT64(itemid, row[0]);        zbx_vector_uint64_append(itemids, itemid);    }    DBfree_result(result);    zbx_vector_uint64_sort(itemids, ZBX_DEFAULT_UINT64_COMPARE_FUNC);    zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

/****************************************************************************** *                                                                            * * Function: save_template_discovery_prototypes                               * *                                                                            * * Purpose: saves host item prototypes in database                            * *                                                                            * * Parameters:  hostid  - [IN] the target host                                * *              items   - [IN] the template items                             * *                                                                            * ******************************************************************************/void	save_template_discovery_prototypes(zbx_uint64_t hostid, zbx_vector_ptr_t *items){	typedef struct	{		zbx_uint64_t	itemid;		zbx_uint64_t	parent_itemid;	}	zbx_proto_t;	DB_RESULT		result;	DB_ROW			row;	char			*sql = NULL;	size_t			sql_alloc = 0, sql_offset = 0;	zbx_vector_uint64_t	itemids;	zbx_vector_ptr_t	prototypes;	zbx_proto_t		*proto;	int 			i;	zbx_db_insert_t		db_insert;	zbx_vector_ptr_create(&prototypes);	zbx_vector_uint64_create(&itemids);	for (i = 0; i < items->values_num; i++)	{		zbx_template_item_t	*item = items->values[i];		/* process only new prototype items */		if (NULL == item->key || 0 == (ZBX_FLAG_DISCOVERY_PROTOTYPE & item->flags))			continue;		zbx_vector_uint64_append(&itemids, item->itemid);	}	if (0 == itemids.values_num)		goto out;	zbx_vector_uint64_sort(&itemids, ZBX_DEFAULT_UINT64_COMPARE_FUNC);	zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset,			"select i.itemid,r.itemid"			" from items i,item_discovery id,items r"			" where i.templateid=id.itemid"				" and id.parent_itemid=r.templateid"				" and r.hostid=" ZBX_FS_UI64				" and",			hostid);	DBadd_condition_alloc(&sql, &sql_alloc, &sql_offset, "i.itemid", itemids.values, itemids.values_num);	result = DBselect("%s", sql);	while (NULL != (row = DBfetch(result)))	{		proto = zbx_malloc(NULL, sizeof(zbx_proto_t));		ZBX_STR2UINT64(proto->itemid, row[0]);		ZBX_STR2UINT64(proto->parent_itemid, row[1]);		zbx_vector_ptr_append(&prototypes, proto);	}	DBfree_result(result);	if (0 == prototypes.values_num)		goto out;	zbx_db_insert_prepare(&db_insert, "item_discovery", "itemdiscoveryid", "itemid",					"parent_itemid", NULL);	for (i = 0; i < prototypes.values_num; i++)	{		proto = prototypes.values[i];		zbx_db_insert_add_values(&db_insert, __UINT64_C(0), proto->itemid, proto->parent_itemid);	}	zbx_db_insert_autoincrement(&db_insert, "itemdiscoveryid");	zbx_db_insert_execute(&db_insert);	zbx_db_insert_clean(&db_insert);out:	zbx_free(sql);	zbx_vector_uint64_destroy(&itemids);	zbx_vector_ptr_clear_ext(&prototypes, zbx_ptr_free);	zbx_vector_ptr_destroy(&prototypes);}

/****************************************************************************** *                                                                            * * Function: save_template_lld_rules                                          * *                                                                            * * Purpose: saves template lld rule item conditions to the target host in     * *          database                                                          * *                                                                            * * Parameters:  items          - [IN] the template items                      * *              rules          - [IN] the ldd rule mapping                    * *              new_conditions - [IN] the number of new item conditions to    * *                                    be inserted                             * *                                                                            * ******************************************************************************/static void	save_template_lld_rules(zbx_vector_ptr_t *items, zbx_vector_ptr_t *rules, int new_conditions){	char				*macro_esc, *value_esc;	int				i, j, index;	zbx_db_insert_t			db_insert;	zbx_lld_rule_map_t		*rule;	zbx_lld_rule_condition_t	*condition;	char				*sql = NULL;	size_t				sql_alloc = 0, sql_offset = 0;	zbx_vector_uint64_t		item_conditionids;	if (0 == rules->values_num)		return;	zbx_vector_uint64_create(&item_conditionids);	if (0 != new_conditions)	{		zbx_db_insert_prepare(&db_insert, "item_condition", "item_conditionid", "itemid", "operator", "macro",				"value", NULL);		/* insert lld rule conditions for new items */		for (i = 0; i < items->values_num; i++)		{			zbx_template_item_t	*item = items->values[i];			if (NULL == item->key)				continue;			if (0 == (ZBX_FLAG_DISCOVERY_RULE & item->flags))				continue;			index = zbx_vector_ptr_bsearch(rules, &item->templateid, ZBX_DEFAULT_UINT64_PTR_COMPARE_FUNC);			if (FAIL == index)			{				THIS_SHOULD_NEVER_HAPPEN;				continue;			}			rule = rules->values[index];			for (j = 0; j < rule->conditions.values_num; j++)			{				condition = rule->conditions.values[j];				zbx_db_insert_add_values(&db_insert, rule->conditionid++, item->itemid,						(int)condition->operator, condition->macro, condition->value);			}		}	}	DBbegin_multiple_update(&sql, &sql_alloc, &sql_offset);	/* update lld rule conditions for existing items */	for (i = 0; i < rules->values_num; i++)	{		rule = rules->values[i];		/* skip lld rules of new items */		if (0 == rule->itemid)			continue;		index = MIN(rule->conditions.values_num, rule->conditionids.values_num);		/* update intersecting rule conditions */		for (j = 0; j < index; j++)		{			condition = rule->conditions.values[j];			macro_esc = DBdyn_escape_string(condition->macro);			value_esc = DBdyn_escape_string(condition->value);			zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "update item_condition"					" set operator=%d,macro='%s',value='%s'"					" where item_conditionid=" ZBX_FS_UI64 ";/n",					(int)condition->operator, macro_esc, value_esc, rule->conditionids.values[j]);			DBexecute_overflowed_sql(&sql, &sql_alloc, &sql_offset);			zbx_free(value_esc);			zbx_free(macro_esc);		}		/* delete removed rule conditions */		for (j = index; j < rule->conditionids.values_num; j++)			zbx_vector_uint64_append(&item_conditionids, rule->conditionids.values[j]);//.........这里部分代码省略.........