sahpi_struct_utils.c

HIP 硬件设备管理标准接口

	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Language: %s\n", 
		 oh_lookup_language(textbuffer->Language));
	oh_append_bigtext(buffer, str);
	
	/* Text Buffer Data Length */
	oh_append_offset(buffer, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Data Length: %d\n", 
		 textbuffer->DataLength);
	oh_append_bigtext(buffer, str);

	/* Text Buffer Data */
	if (textbuffer->DataLength) {
		oh_append_offset(buffer, offsets);
		memset(str, 0, SAHPI_MAX_TEXT_BUFFER_LENGTH);
		oh_append_bigtext(buffer, "Data: ");
		if (textbuffer->DataType == SAHPI_TL_TYPE_BINARY)
			oh_append_data(buffer, textbuffer->Data, textbuffer->DataLength);
		else
			oh_append_bigtext(buffer, textbuffer->Data);
		oh_append_bigtext(buffer, "\n");
	}

	return(SA_OK);
}

/**
 * oh_decode_capability:
 * @ResourceCapabilities: enum value of type SaHpiCapabilitiesT.
 * @buffer:  Location to store the string.
 *
 * Converts @ResourceCapabilities type into a string based on 
 * @ResourceCapabilities HPI definition. For example:
 * @ResourceCapabilities = SAHPI_CAPABILITY_RESOURCE | SAHPI_CAPABILITY_EVENT_LOG
 * returns a string "RESOURCE | EVENT_LOG".
 * 
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - @buffer is NULL
 **/
SaErrorT oh_decode_capability(SaHpiCapabilitiesT ResourceCapabilities,
			      SaHpiTextBufferT *buffer)
{
	int found, i;
	SaErrorT err;
	SaHpiTextBufferT working;

	if (!buffer) {
		return(SA_ERR_HPI_INVALID_PARAMS);
	}

	err = oh_init_textbuffer(&working);
	if (err) { return(err); }

	found = 0;
        if (ResourceCapabilities & SAHPI_CAPABILITY_AGGREGATE_STATUS) {
		found++;
		err = oh_append_textbuffer(&working, "AGGREGATE_STATUS | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_ANNUNCIATOR) {
		found++;
		err = oh_append_textbuffer(&working, "ANNUNCIATOR | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_CONFIGURATION) {
		found++;
		err = oh_append_textbuffer(&working, "CONFIGURATION | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_CONTROL) {
		found++;
		err = oh_append_textbuffer(&working, "CONTROL | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_EVENT_LOG) {
		found++;
		err = oh_append_textbuffer(&working, "EVENT_LOG | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_EVT_DEASSERTS) {
		found++;
		err = oh_append_textbuffer(&working, "EVT_DEASSERTS | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_FRU) {
		found++;
		err = oh_append_textbuffer(&working, "FRU | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_INVENTORY_DATA) {
		found++;
		err = oh_append_textbuffer(&working, "INVENTORY_DATA | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_MANAGED_HOTSWAP) {
		found++;
		err = oh_append_textbuffer(&working, "MANAGED_HOTSWAP | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_POWER) {
		found++;
		err = oh_append_textbuffer(&working, "POWER | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_RDR) {
		found++;
		err = oh_append_textbuffer(&working, "RDR | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_RESET) {
		found++;
		err = oh_append_textbuffer(&working, "RESET | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_RESOURCE) {
		found++;
		err = oh_append_textbuffer(&working, "RESOURCE | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_SENSOR) {
		found++;
		err = oh_append_textbuffer(&working, "SENSOR | ");
		if (err) { return(err); }
	}
        if (ResourceCapabilities & SAHPI_CAPABILITY_WATCHDOG) {
		found++;
		err = oh_append_textbuffer(&working, "WATCHDOG | ");
		if (err) { return(err); }
	}

	if (found) {
		for (i=0; i<OH_ENCODE_DELIMITER_LENGTH + 1; i++) {
			working.Data[working.DataLength - i] = 0x00;
		}
		working.DataLength = working.DataLength - (i+1);
	}
				
 	oh_copy_textbuffer(buffer, &working);

	return(SA_OK);
}

/**
 * oh_fprint_rptentry:
 * @stream: File handle.
 * @rptentry: Pointer to SaHpiRptEntryT to be printed.
 * @offsets:  Number of offsets to start printing structure.
 * 
 * Prints the member data contained in SaHpiRptEntryT struct to a file.
 * The MACRO oh_print_rptentry(), uses this function to print to STDOUT. 
 *
 * Returns:       
 * SA_OK - normal operation.
 **/
SaErrorT oh_fprint_rptentry(FILE *stream, const SaHpiRptEntryT *rptentry, int offsets)
{
	SaErrorT err = SA_OK;
	oh_big_textbuffer mybuf;
	SaHpiTextBufferT tmpbuffer; 
	char* str = tmpbuffer.Data;

	if (!stream || !rptentry) return(SA_ERR_HPI_INVALID_PARAMS);
	
	oh_init_bigtext(&mybuf);
	offsets++;
	
	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "EntryId: %d\n", rptentry->EntryId);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, (offsets));
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ResourceId: %d\n", rptentry->ResourceId);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Entity Path: ");
	oh_append_bigtext(&mybuf, str);
        entitypath2string(&rptentry->ResourceEntity, str, SAHPI_MAX_TEXT_BUFFER_LENGTH);
	oh_append_bigtext(&mybuf, str);
	oh_append_bigtext(&mybuf, "\n");

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Capability: ");
	oh_append_bigtext(&mybuf, str);
	oh_decode_capability(rptentry->ResourceCapabilities, &tmpbuffer);
	oh_append_bigtext(&mybuf, str);
	oh_append_bigtext(&mybuf, "\n");	

	oh_append_offset(&mybuf, offsets);
	/* FIXME:: Need a oh_decode_hscapability() that does the pretty OR strings */
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "HotSwap Capability: %d\n",
		 rptentry->HotSwapCapabilities);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ResourceFailed: %s\n",
		 (rptentry->ResourceFailed == SAHPI_TRUE) ? "TRUE" : "FALSE" );
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ResourceTag:\n");
	oh_append_bigtext(&mybuf, str);
	oh_build_textbuffer(&mybuf, &(rptentry->ResourceTag), offsets + 1);

	err = oh_fprint_bigtext(stream, &mybuf); 					
	return(err);
}

/**
 * oh_fprint_rdr:
 * @stream: File handle.
 * @thisrdr: Pointer to SaHpiRdrT to be printed.
 * @offsets: Number of offsets to start printing structure.
 * 
 * Prints the member data contained in SaHpiRdrT struct to a file.
 * The MACRO oh_print_rdr(), uses this function to print to STDOUT. 
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
SaErrorT oh_fprint_rdr(FILE *stream, const SaHpiRdrT *thisrdr, int offsets)
{
	SaErrorT err;
	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];
	oh_big_textbuffer mybuf, mybuf1;

	if (!stream || !thisrdr) return(SA_ERR_HPI_INVALID_PARAMS);
					
	oh_init_bigtext(&mybuf);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "RecordId: %d\n", thisrdr->RecordId);
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "RdrType: %s\n", oh_lookup_rdrtype(thisrdr->RdrType));
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Entity Path: ");
	oh_append_bigtext(&mybuf, str);
        entitypath2string(&thisrdr->Entity, str, SAHPI_MAX_TEXT_BUFFER_LENGTH);
	oh_append_bigtext(&mybuf, str);
	oh_append_bigtext(&mybuf, "\n");
	
	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "IsFru: %s\n",
		 (thisrdr->IsFru == SAHPI_TRUE) ? "TRUE" : "FALSE" );
	oh_append_bigtext(&mybuf, str);

	oh_init_bigtext(&mybuf1);
	switch(thisrdr->RdrType) 
	{
		case SAHPI_CTRL_RDR:
			err = oh_build_ctrlrec(&mybuf1,
				(const SaHpiCtrlRecT*) &thisrdr->RdrTypeUnion.CtrlRec, offsets);
			break;
		case SAHPI_SENSOR_RDR:
			err = oh_build_sensorrec(&mybuf1,
				(const SaHpiSensorRecT*) &thisrdr->RdrTypeUnion.SensorRec, offsets);
			break;
		case SAHPI_INVENTORY_RDR:
			err = oh_build_invrec(&mybuf1,
				(const SaHpiInventoryRecT*) &thisrdr->RdrTypeUnion.InventoryRec, offsets);
			break;
		case SAHPI_WATCHDOG_RDR:
			err = oh_build_wdogrec(&mybuf1,
				(const SaHpiWatchdogRecT*) &thisrdr->RdrTypeUnion.WatchdogRec, offsets); 
			break;
		case SAHPI_ANNUNCIATOR_RDR:
			err = oh_build_annrec(&mybuf1,
				(const SaHpiAnnunciatorRecT*) &thisrdr->RdrTypeUnion.AnnunciatorRec, offsets);
			break;
		case SAHPI_NO_RECORD:
			oh_append_offset(&mybuf1, offsets);
			oh_append_bigtext(&mybuf1,oh_lookup_rdrtype(thisrdr->RdrType));
			break;
		default:
			oh_append_bigtext(&mybuf1,"Invalid/Unknown RDR Type\n");

	}

	oh_append_bigtext(&mybuf, mybuf1.Data);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "IdString:\n");
	oh_append_bigtext(&mybuf, str);
	oh_build_textbuffer(&mybuf, &(thisrdr->IdString), offsets + 1);

	err = oh_fprint_bigtext(stream, &mybuf); 					
	return(err);
}

/**
 * oh_build_ctrlrec:
 * @textbuff: Buffer into which to store flattened ctrl rec structure.
 * @thisrdrunion: Pointer to SaHpiRdrTypeUnionT to be flattened.
 * @offsets: Number of offsets to start printing structure.
 * 
 * Flatten member data contained in SaHpiCtrlRecT struct to a text buffer.
 *
 * Returns:
 * SA_OK - normal operation.
 * SA_ERR_HPI_INVALID_PARAMS - Pointer parameter(s) are NULL.
 **/
static SaErrorT oh_build_ctrlrec(oh_big_textbuffer *textbuf, const SaHpiCtrlRecT *ctrlrec, int offsets)
{
	SaErrorT err;
	char str[SAHPI_MAX_TEXT_BUFFER_LENGTH];
	oh_big_textbuffer mybuf;
	SaHpiTextBufferT  smallbuf;

	if (!textbuf || !ctrlrec) return(SA_ERR_HPI_INVALID_PARAMS);

	oh_init_bigtext(&mybuf);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Control Number: %d\n",ctrlrec->Num);
	oh_append_bigtext(&mybuf, str);
	
	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Control Output Type: %s\n",
		 oh_lookup_ctrloutputtype(ctrlrec->OutputType));
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Control Type: %s\n",
		 oh_lookup_ctrltype(ctrlrec->Type));
	oh_append_bigtext(&mybuf, str);
	offsets++;

	oh_append_offset(&mybuf, offsets);

	switch(ctrlrec->Type) {
	case SAHPI_CTRL_TYPE_DIGITAL:
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Digital Default: %s\n",
			 oh_lookup_ctrlstatedigital(ctrlrec->TypeUnion.Digital.Default));
		break;
	case SAHPI_CTRL_TYPE_DISCRETE:
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Discrete Default: %d\n",
			 ctrlrec->TypeUnion.Discrete.Default);
		break;
	case SAHPI_CTRL_TYPE_ANALOG:
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Analog Min: %d\n",
			 ctrlrec->TypeUnion.Analog.Min);
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Analog Max: %d\n",
			 ctrlrec->TypeUnion.Analog.Max);
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Analog Default: %d\n",
			 ctrlrec->TypeUnion.Analog.Default);
		break;
	case SAHPI_CTRL_TYPE_STREAM:
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Stream Default:\n");
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 1+offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Repeat: %s\n",
			 &(ctrlrec->TypeUnion.Stream.Default.Repeat));
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 1+offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "StreamLength: %d\n",
			 ctrlrec->TypeUnion.Stream.Default.StreamLength);
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 1+offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Stream Default: %s\n",
			 ctrlrec->TypeUnion.Stream.Default.Stream);
		break;
	case SAHPI_CTRL_TYPE_TEXT:
		break;
	case SAHPI_CTRL_TYPE_OEM:
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Oem:\n");
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 1+offsets);
		err = oh_decode_manufacturerid(ctrlrec->TypeUnion.Oem.MId, &smallbuf);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ManufacturerId: %s\n",
			 smallbuf.Data);
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 1+offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ConfigData: %s\n",
			 ctrlrec->TypeUnion.Oem.ConfigData);
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 1+offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Default:\n");
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 2+offsets);
		err = oh_decode_manufacturerid(ctrlrec->TypeUnion.Oem.Default.MId, &smallbuf);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "ManufacturerId: %s\n",
			 smallbuf.Data);
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 2+offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "BodyLength: %d\n",
			 ctrlrec->TypeUnion.Oem.Default.BodyLength);
		oh_append_bigtext(&mybuf, str);
		oh_append_offset(&mybuf, 2+offsets);
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Body: %s\n",
			 ctrlrec->TypeUnion.Oem.Default.Body);
		break;
	default:
		snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Invalid ControlType Detected\n");
	}

	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "DefaultMode:\n");
	oh_append_bigtext(&mybuf, str);

	oh_append_offset(&mybuf, 1+offsets);
	snprintf(str, SAHPI_MAX_TEXT_BUFFER_LENGTH, "Mode: %s\n", 
		 oh_lookup_ctrlmode(ctrlrec->DefaultMode.Mode));
	oh_append_bigtext(&mybuf, str);