usedir.c

sybase数据库ct library的开发,使用了所以有函数

	return CS_SUCCEED;

} /* attr_display_values() */

/*
** attr_val_as_string() -- Convert the contents of a CS_ATTRVALUE union to
**   a printable string.
**
** Parameters
**   attr_metadata -- The CS_ATTRIBUTE structure containing metadata
**       for the attribute value.
**   val -- Pointer to the CS_ATTRVALUE union.
**   buffer -- Address of the buffer to receive the converted value.
**   buflen -- Length of *buffer in bytes.
**   outlen -- If supplied, will be set to the number of bytes written
**      to *buffer.
**
** Returns
**   CS_SUCCEED or CS_FAIL.
*/
CS_RETCODE
attr_val_as_string(attr_metadata, val, buffer, buflen, outlen)
CS_ATTRIBUTE       *attr_metadata;
CS_ATTRVALUE       *val;
CS_CHAR            *buffer;
CS_INT              buflen;
CS_INT             *outlen;
{
	CS_CHAR             outbuf[CS_MAX_DS_STRING * 4];
	CS_CHAR             scratch[CS_MAX_DS_STRING];
	CS_RETCODE          ret;

	if (buflen == 0 || buffer == NULL)
	{
		return CS_FAIL;
	}
	if (outlen != NULL)
	{
		*outlen = 0;
	}

	switch ((int)attr_metadata->attr_syntax)
	{
	case CS_ATTR_SYNTAX_STRING:
		sprintf(outbuf, "%.*s",
			(int)(val->value_string.str_length),
			val->value_string.str_buffer);
		break;

	case CS_ATTR_SYNTAX_BOOLEAN:
		sprintf(outbuf, "%s",
			val->value_boolean == CS_TRUE ? "True" : "False");
		break;

	case CS_ATTR_SYNTAX_INTEGER:
	case CS_ATTR_SYNTAX_ENUMERATION:

		/*
		** Some enumerated or integer attribute values should be
		** converted into an english-language equivalent.
		** attr_enum_english_name() contains all the logic to
		** convert #define's into human language.
		*/
		ret = attr_enum_english_name((CS_INT)(val->value_enumeration),
					     &(attr_metadata->attr_type),
					scratch, CS_MAX_DS_STRING, NULL);
		if (ret != CS_SUCCEED)
		{
			ex_error(
		    "attr_val_as_string: attr_enum_english_name() failed.");
			return CS_FAIL;
		}
		sprintf(outbuf, "%s", scratch);
		break;

	case CS_ATTR_SYNTAX_TRANADDR:

		/*
		** The access type is an enumerated value. Get an english
		** language string for it.
		*/
		switch ((int)(val->value_tranaddr.addr_accesstype))
		{
		case CS_ACCESS_CLIENT:
			sprintf(scratch, "client");
			break;
		case CS_ACCESS_ADMIN:
			sprintf(scratch, "administrative");
			break;
		case CS_ACCESS_MGMTAGENT:
			sprintf(scratch, "management agent");
			break;
		default:
			sprintf(scratch, "%ld", 
				(long)(val->value_tranaddr.addr_accesstype));
			break;
		}

		sprintf(outbuf, 
			"Access type '%s'; Transport type '%s'; Address '%s'",
			scratch,
			val->value_tranaddr.addr_trantype.str_buffer,
			val->value_tranaddr.addr_tranaddress.str_buffer);

		break;

	case CS_ATTR_SYNTAX_OID:
		sprintf(outbuf, "%.*s",
			(int)(val->value_oid.oid_length),
			val->value_oid.oid_buffer);
		break;

	default:
		sprintf(outbuf, "Unknown attribute value syntax");
		break;

	} /* switch */

	if (STRLEN(outbuf) + 1 > buflen || buffer == NULL)
	{
		return CS_FAIL;
	}
	else
	{
		sprintf(buffer, "%s", outbuf);
		if (outlen != NULL)
		{
			*outlen = STRLEN(outbuf) + 1;
		}
	}

	return CS_SUCCEED;

} /* attr_val_as_string() */

/*
** attr_enum_english_name()
**   Based on the attribute type, associate an english phrase with
**   a CS_INT value. Use this function to get meaningful names for
**   CS_ATTR_SYNTAX_ENUMERATION or CS_ATTR_SYNTAX_INTEGER attribute
**   values.
**
**   If the attribute type represents a quantity and not a numeric code,
**   then the value is converted to the string representation of the
**   number. Unknown codes are handled the same way.
**
** Parameters
**   enum_val -- The integer value to convert to a string.
**   attr_type -- Pointer to an OID structure containing the OID string
**      that tells the attribute's type.
**   buffer -- Address of the buffer to receive the converted value.
**   buflen -- Length of *buffer in bytes.
**   outlen -- If supplied, will be set to the number of bytes written
**      to *buffer.
**
** Bugs
**   This function only knows about the attributes of the Server
**   Directory object as it was defined at the time the function
**   was created.
**
** Returns
**   CS_SUCCEED or CS_FAIL
*/
CS_RETCODE
attr_enum_english_name(enum_val, attr_type, buffer, buflen, outlen)
CS_INT              enum_val;
CS_OID             *attr_type;
CS_CHAR            *buffer;
CS_INT              buflen;
CS_INT             *outlen;
{
	CS_CHAR             outbuf[CS_MAX_DS_STRING];

	if (buffer == NULL || buflen <= 0)
	{
		return CS_FAIL;
	}
	if (outlen != NULL)
	{
		*outlen = 0;
	}

	/*
	** Server version number.
	*/
	if (match_OID(attr_type, CS_OID_ATTRVERSION))
	{
		sprintf(outbuf, "%ld", (long)enum_val);
	}

	/*
	** Server's status.
	*/
	else if (match_OID(attr_type, CS_OID_ATTRSTATUS))
	{
		switch ((int)enum_val)
		{
		case CS_STATUS_ACTIVE:
			sprintf(outbuf, "running");
			break;
		case CS_STATUS_STOPPED:
			sprintf(outbuf, "stopped");
			break;
		case CS_STATUS_FAILED:
			sprintf(outbuf, "failed");
			break;
		case CS_STATUS_UNKNOWN:
			sprintf(outbuf, "unknown");
			break;
		default:
			sprintf(outbuf, "%ld", (long)enum_val);
			break;
		}
	}

	/*
	** Anything else is either an enumerated type that we don't know
	** about, or it really is just a number. We print the numeric
	** value.
	*/
	else
	{
		sprintf(outbuf, "%ld", (long)enum_val);
	}

	/*
	** Transfer output to the caller's buffer.
	*/
	if (STRLEN(outbuf) + 1 > buflen || buffer == NULL)
	{
		return CS_FAIL;
	}
	else
	{
		sprintf(buffer, "%s", outbuf);
		if (outlen != NULL)
		{
			*outlen = STRLEN(outbuf) + 1;
		}
	}

	return CS_SUCCEED;

} /* attr_enum_english_name() */

/*
** match_OID()
**   Compare a pre-defined OID string to the contents of a
**   CS_OID structure.
**
** Parameters
**   oid -- Pointer to a CS_OID structure. OID->oid_length should be
**     the length of the string, not including any null-terminator.
**   oid_string -- Null-terminated OID string to compare.
**
** Returns
**  Non-zero if contents of oid->oid_buffer matches contents
**  of oid_string.
*/
int
match_OID(oid, oid_string)
CS_OID             *oid;
CS_CHAR            *oid_string;
{
        return ( (oid->oid_length == STRLEN(oid_string))
	  && (strncmp(oid_string, oid->oid_buffer, oid->oid_length) == 0));
} /* match_OID() */

/*
** sil_init_list() -- Initialize an instance of the
**    SERVER_INFO_LIST abstract data type.
**
** Parameters
**   pplist -- address of a SERVER_INFO_LIST *.
**
** Returns
**   CS_SUCCEED or CS_FAIL.
*/
CS_RETCODE
sil_init_list(pplist)
SERVER_INFO_LIST  **pplist;
{
	CS_INT              i;

	/*
	** Allocate a SERVER_INFO_LIST structure.
	*/
	*pplist = (SERVER_INFO_LIST *)malloc(sizeof(SERVER_INFO_LIST));

	if (*pplist == (SERVER_INFO_LIST *)NULL)
	{
		ex_error("sil_init_list: Out of memory.");
		return CS_FAIL;
	}

	/*
	** Allocate the array.
	*/
	(*pplist)->servers = (SERVER_INFO *)malloc(sizeof(SERVER_INFO)
						   * MAX_SERVER_LIST);

	if ((*pplist)->servers == (SERVER_INFO *)NULL)
	{
		ex_error("sil_init_list: Out of memory.");
		return CS_FAIL;
	}

	for (i = 0; i < MAX_SERVER_LIST; i++)
	{
		(*pplist)->servers[i].object = NULL;
	}

	(*pplist)->len = 0;

	return CS_SUCCEED;

} /* sil_init_list */

/*
** sil_add_object() -- Insert a CS_DS_OBJECT pointer
**   into an instance of the SERVER_INFO_LIST abstract
**   data type.
**
** Parameters
**   slp -- Pointer to an initialized SERVER_INFO_LIST.
**   ds_object -- Pointer to be inserted.
**
** Returns
**   CS_SUCCEED or CS_FAIL.
*/
CS_RETCODE
sil_add_object(slp, ds_object)
SERVER_INFO_LIST   *slp;
CS_DS_OBJECT       *ds_object;
{
	int                 i;

	/*
	** Check that the list has been initialized.
	*/
	if (slp == (SERVER_INFO_LIST *)NULL)
	{
		ex_error(
		  "sil_add_object: Received NULL server list parameter.");
		return CS_FAIL;
	}

	/*
	** List full?
	*/
	if (slp->len >= MAX_SERVER_LIST)
	{
		ex_error("sil_add_object: List is full.");
		return CS_FAIL;
	}

	/*
	** Perform the insert operation.
	*/
	i = slp->len;
	slp->servers[i].object = ds_object;
	slp->len += 1;

	return CS_SUCCEED;

} /* sil_add_object() */

/*
** sil_drop_list() -- Free the memory associated with
**   an instance of the SERVER_INFO_LIST abstract data
**   type.
**
** Parameters
**   conn -- the connection associated with the CS_DS_OBJECTS
**     stored in the list.
**   slp -- pointer to an initialized SERVER_INFO_LIST.
**
** Returns
**   CS_SUCCEED or CS_FAIL.
*/
CS_RETCODE
sil_drop_list(conn, slp)
CS_CONNECTION      *conn;
SERVER_INFO_LIST   *slp;
{
	CS_RETCODE          ret;
	int                 i;

	/*
	** Check that the list has been initialized.
	*/
	if (slp == (SERVER_INFO_LIST *)NULL)
	{
		ex_error(
		  "sil_drop_list: Received NULL server list parameter.");
		return CS_FAIL;
	}

	for (i = 0; i < MAX_SERVER_LIST; i++)
	{

		/*
		** Drop the object.
		*/
		if (slp->servers[i].object != NULL)
		{
			ret = ct_ds_dropobj(conn, slp->servers[i].object);
			if (ret != CS_SUCCEED)
			{
				ex_error(
				  "sil_drop_list: ct_ds_dropobj() failed.");
				return CS_FAIL;
			}
		}

	} /* while */

	/*
	** Drop the array.
	*/
	free(slp->servers);

	/*
	** Drop the list structure.
	*/
	free(slp);

	return CS_SUCCEED;

} /* sil_drop_list() */

/*
** sil_extract_object()
**   Retrieve a CS_DS_OBJECT from a node in the server list.
**
** Parameters
**   slp -- Pointer to an initialized SERVER_LIST_INFO structure. This
**      routine fails if it is NULL.
**   number -- The position of the list item of interest. The
**      first is 1. This routine fails if number is out of range.
**   pobject -- Address of a CS_DS_OBJECT pointer. *pobject is
**      a pointer to the extracted object handle upon successful
**      return.
**
** Returns
**   CS_SUCCEED or CS_FAIL.
*/
CS_RETCODE
sil_extract_object(slp, number, pobject)
SERVER_INFO_LIST   *slp;
CS_INT              number;
CS_DS_OBJECT      **pobject;
{
	if (slp == NULL || pobject == NULL)
	{
		return CS_FAIL;
	}

	if (number < 1 || number > slp->len)
	{
		return CS_FAIL;
	}

	*pobject = slp->servers[number - 1].object;

	return CS_SUCCEED;

} /* sil_extract_object() */

/*
** sil_list_len() -- Returns the length of an instance of the
**   SERVER_INFO_LIST abstract data type.
**
** Parameters
**   slp -- Pointer to an initialized SERVER_INFO_LIST.
**
** Returns
**   CS_SUCCEED or CS_FAIL.
*/
CS_INT
sil_list_len(slp)
SERVER_INFO_LIST   *slp;
{
	if (slp == NULL)
	{
		return 0;
	}

	return slp->len;

} /* sil_list_len() */