/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
*/
#include <stdlib.h>
#include <stdarg.h>
#include <strings.h>
#include <time.h>
#include "asr_buf.h"
#include "asr_err.h"
#include "asr_mem.h"
#include "asr_nvl.h"
/*
* libnvpair wrappers
*/
nvlist_t *
{
(void) asr_set_errno(EASR_NOMEM);
return (NULL);
}
return (nvl);
}
nvlist_t *
{
(void) asr_set_errno(EASR_NOMEM);
return (NULL);
}
return (dst);
}
int
{
return (asr_set_errno(EASR_NOMEM));
}
return (ASR_OK);
}
/*
* Frees an nvlist if it isn't null
*/
void
{
}
/*
* Adds a string to a name value list. If the value is NULL then nothing is
* added.
* Returns non-zero if there is an error.
*/
int
{
int err = 0;
return (ASR_FAILURE);
return (err);
}
/*
* Removes a string property from a name value list.
* Returns non-zero if there is an error.
*/
int
{
int err = 0;
return (ASR_FAILURE);
return (err);
}
/*PRINTFLIKE3*/
int
const char *format, ...)
{
char *value;
int err = 0;
return (ASR_FAILURE);
err = -1;
if (err == 0)
return (err);
}
/*
* Gets a string value form an nvlist. If the property isn't found or there
* is an error then NULL is returned
*/
char *
{
int err;
char *value;
if (err != 0) {
return (NULL);
}
return (value);
}
/*
* Copies a property value from a source nvlist to a dest list. If the value
* is NULL then it is removed in the dest list.
*/
int
{
else
}
/*
* Copies a property value from a source nvlist to a dest list. If the value
* is NULL then the default value is used.
*/
int
{
else
}
/*
* Gets a string value form an nvlist. If the property isn't found or there
* is an error then the default value is returned
*/
char *
{
int err;
char *value;
if (err != 0) {
return (dval);
}
return (value);
}
int
{
int err = 0;
int out;
}
if (out < 0) {
err++;
} else {
err++;
}
}
return (err);
}
static int
{
int i;
char c;
if (c == '\n') {
return (ASR_FAILURE);
} else if (c == '\t') {
return (ASR_FAILURE);
} else if (c == '\\') {
return (ASR_FAILURE);
} else if (c == '"') {
return (ASR_FAILURE);
return (ASR_FAILURE);
} else if (c == '\'') {
return (ASR_FAILURE);
return (ASR_FAILURE);
} else {
return (ASR_FAILURE);
}
}
}
return (ASR_OK);
}
/*
* Prints elements in an event buffer in property format
*/
static int
{
int err = 0;
int i;
char *name;
return (ASR_FAILURE);
return (ASR_FAILURE);
if (type == DATA_TYPE_NVLIST) {
char *pname;
if ((err = asr_buf_append(
break;
} else {
}
continue;
}
if (type == DATA_TYPE_NVLIST_ARRAY) {
for (i = 0; i < nelem; i++) {
"%s.%d", name, i);
else
if (err != 0)
break;
asr_buf_data(buf));
}
continue;
}
err = ASR_FAILURE;
} else {
err = ASR_FAILURE;
}
if (err != 0)
break;
nelem = 0;
switch (type) {
case DATA_TYPE_BOOLEAN:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_BOOLEAN_VALUE:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_BYTE:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_INT8:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_UINT8:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_INT16:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_UINT16:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_INT32:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_UINT32:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_INT64:
{
err = ASR_FAILURE;
break;
}
case DATA_TYPE_UINT64:
{
err = ASR_FAILURE;
break;
}
#ifdef DATA_TYPE_DOUBLE
case DATA_TYPE_DOUBLE:
{
double val;
err = ASR_FAILURE;
break;
}
#endif
case DATA_TYPE_STRING:
{
char *val;
break;
}
case DATA_TYPE_BOOLEAN_ARRAY:
{
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_BYTE_ARRAY:
{
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_INT8_ARRAY:
{
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_UINT8_ARRAY:
{
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_INT16_ARRAY:
{
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_UINT16_ARRAY:
{
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_INT32_ARRAY:
{
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_UINT32_ARRAY:
{
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_INT64_ARRAY:
{
(longlong_t)val[i]) < 0)
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_UINT64_ARRAY:
{
(u_longlong_t)val[i]) < 0)
err = ASR_FAILURE;
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_STRING_ARRAY:
{
char **val;
err = ASR_FAILURE;
break;
}
if ((err = asr_nvl_print_prop_string(
break;
err = ASR_FAILURE;
break;
}
if (i < nelem - 1)
err = ASR_FAILURE;
}
break;
}
case DATA_TYPE_HRTIME:
{
err = ASR_FAILURE;
break;
}
default:
err = ASR_FAILURE;
break;
}
err = ASR_FAILURE;
}
return (err);
} /* asr_nvl_print_prop_path */
/*
* Prints elements in an event buffer in property format
*/
int
{
}
static char *
{
int i, j;
char *s;
(void) asr_set_errno(EASR_NOMEM);
return (NULL);
}
for (i = 0, j = 0; i < vlen; i++, j++) {
char c = value[i];
if (c == '\\') {
c = value[++i];
if (c == 'n') {
c = '\n';
} else if (c == 't') {
c = '\t';
}
}
s[j] = c;
}
s[j - 1] = '\0';
return (s);
}
/*
* Reads properties from a file into a nvlist.
* This only supports string data types.
*/
int
{
int err = 0;
int line;
char *value;
char *p, *s;
for (line = 1;
line++) {
if (buf[0] == '#')
continue;
for (p = buf; *p != '\0'; p++) {
if (*p == '=') {
*p = '\0';
value = ++p;
break;
}
}
s = convert_nvpropstr(value);
if (s != NULL) {
free(s);
}
}
if (err != 0) {
(void) asr_set_errno(EASR_NVLIST);
}
return (err);
}
static void
{
while (depth-- > 0)
}
/*
* Prints elements in an event buffer in property format
*/
static void
{
int i;
char *name;
return;
if (first) {
first = 0;
if (depth > 1)
} else {
}
nelem = 0;
switch (type) {
case DATA_TYPE_BOOLEAN:
{
break;
}
case DATA_TYPE_BOOLEAN_VALUE:
{
break;
}
case DATA_TYPE_BYTE:
{
break;
}
case DATA_TYPE_INT8:
{
break;
}
case DATA_TYPE_UINT8:
{
break;
}
case DATA_TYPE_INT16:
{
break;
}
case DATA_TYPE_UINT16:
{
break;
}
case DATA_TYPE_INT32:
{
break;
}
case DATA_TYPE_UINT32:
{
break;
}
case DATA_TYPE_INT64:
{
break;
}
case DATA_TYPE_UINT64:
{
break;
}
#ifdef DATA_TYPE_DOUBLE
case DATA_TYPE_DOUBLE:
{
double val;
break;
}
#endif
case DATA_TYPE_STRING:
{
char *val;
break;
}
case DATA_TYPE_BOOLEAN_ARRAY:
{
for (i = 0; i < nelem; i++) {
"true" : "false");
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_BYTE_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_INT8_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_UINT8_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_INT16_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_UINT16_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_INT32_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_UINT32_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_INT64_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_UINT64_ARRAY:
{
for (i = 0; i < nelem; i++) {
(u_longlong_t)val[i]);
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_STRING_ARRAY:
{
char **val;
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_HRTIME:
{
break;
}
case DATA_TYPE_NVLIST:
{
break;
}
case DATA_TYPE_NVLIST_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
default:
break;
}
}
}
void
{
}
void
{
}
static int
{
int err = 0;
while (depth-- > 0)
return (err);
}
static int
{
int i;
int err = 0;
char c;
if (c == '\n') {
} else if (c == '\t') {
} else if (c == '\\') {
} else if (c == '"') {
} else if (c == '\'') {
} else {
}
}
}
return (err);
}
/*
* Prints elements in an event buffer in property format
*/
void
{
int i;
char *name;
return;
if (first) {
first = 0;
if (depth > 1)
} else {
}
nelem = 0;
switch (type) {
case DATA_TYPE_BOOLEAN:
{
break;
}
case DATA_TYPE_BOOLEAN_VALUE:
{
break;
}
case DATA_TYPE_BYTE:
{
break;
}
case DATA_TYPE_INT8:
{
break;
}
case DATA_TYPE_UINT8:
{
break;
}
case DATA_TYPE_INT16:
{
break;
}
case DATA_TYPE_UINT16:
{
break;
}
case DATA_TYPE_INT32:
{
break;
}
case DATA_TYPE_UINT32:
{
break;
}
case DATA_TYPE_INT64:
{
break;
}
case DATA_TYPE_UINT64:
{
break;
}
#ifdef DATA_TYPE_DOUBLE
case DATA_TYPE_DOUBLE:
{
double val;
break;
}
#endif
case DATA_TYPE_STRING:
{
char *val;
break;
}
case DATA_TYPE_BOOLEAN_ARRAY:
{
for (i = 0; i < nelem; i++) {
"true" : "false");
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_BYTE_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_INT8_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_UINT8_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_INT16_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_UINT16_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_INT32_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_UINT32_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_INT64_ARRAY:
{
for (i = 0; i < nelem; i++) {
(longlong_t)val[i]);
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_UINT64_ARRAY:
{
for (i = 0; i < nelem; i++) {
(u_longlong_t)val[i]);
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_STRING_ARRAY:
{
char **val;
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
case DATA_TYPE_HRTIME:
{
break;
}
case DATA_TYPE_NVLIST:
{
break;
}
case DATA_TYPE_NVLIST_ARRAY:
{
for (i = 0; i < nelem; i++) {
if (i < nelem - 1)
}
break;
}
default:
(void) asr_buf_append(out,
"unknown data type (%d)", type);
break;
}
}
(void) asr_buf_terminate(out);
}
{
return (out);
}
{
return (out);
}