staprint.c

SecuDe是一个由安全应用程序接口组成,对验证机制、证件处理、PEM、X.400报文处理和密钥管理提供支持。SecuDe提供DES、 RSA杂凑函数、密钥生成以及数字签名的生成和核实等多种密码机制。

	SecMess        *sec_mess;
{

	fprintf(stdout, "sec_mess                :\n");
	switch (sec_mess->command) {
	case SEC_NORMAL:
		fprintf(stdout, "    command             : SEC_NORMAL\n");
		break;
	case AUTHENTIC:
		fprintf(stdout, "    command             : AUTHENTIC\n");
		break;
	case CONCEALED:
		fprintf(stdout, "    command             : CONCEALED\n");
		break;
	case COMBINED:
		fprintf(stdout, "    command             : COMBINED\n");
		break;
	default:
		fprintf(stdout, "    command             : undefined\n");
		break;
	};

	switch (sec_mess->response) {
	case SEC_NORMAL:
		fprintf(stdout, "    response            : SEC_NORMAL\n");
		break;
	case AUTHENTIC:
		fprintf(stdout, "    response            : AUTHENTIC\n");
		break;
	case CONCEALED:
		fprintf(stdout, "    response            : CONCEALED\n");
		break;
	case COMBINED:
		fprintf(stdout, "    response            : COMBINED\n");
		break;
	default:
		fprintf(stdout, "    response            : undefined\n");
		break;
	};

}
void
print_datasel(data_sel)
	DataSel        *data_sel;
{

	fprintf(stdout, "data_sel                :\n");
	switch (data_sel->data_struc) {
	case LIN_FIX:
		fprintf(stdout, "    data_struc          : LIN_FIX\n");
		fprintf(stdout, "    record_id           : %d\n", data_sel->data_ref.record_sel.record_id);
		fprintf(stdout, "    record_pos          : %d\n", data_sel->data_ref.record_sel.record_pos);
		break;
	case LIN_VAR:
		fprintf(stdout, "    data_struc          : LIN_VAR\n");
		fprintf(stdout, "    record_id           : %d\n", data_sel->data_ref.record_sel.record_id);
		fprintf(stdout, "    record_pos          : %d\n", data_sel->data_ref.record_sel.record_pos);
		break;
	case CYCLIC:
		fprintf(stdout, "    data_struc 	  : CYCLIC\n");
		fprintf(stdout, "    element_ref         : %d\n", data_sel->data_ref.element_sel.element_ref);
		fprintf(stdout, "    element_no          : %d\n", data_sel->data_ref.element_sel.element_no);
		break;
	case TRANSPARENT:
		fprintf(stdout, "    data_struc          : TRANSPARENT\n");
		fprintf(stdout, "    string_sel          : %d\n", data_sel->data_ref.string_sel);
		break;
	default:
		fprintf(stdout, "    data_struc 	  : undefined\n");
		break;
	};
}
void
print_inforeq(info_req)
	FileInfoReq     info_req;
{

	switch (info_req) {
	case NONE_INFO:
		fprintf(stdout, "file_info_req           : NONE\n");
		break;
	case SHORT_INFO:
		fprintf(stdout, "file_info_req           : SHORT\n");
		break;
	default:
		fprintf(stdout, "file_info_req           : undefined\n");
		break;
	};


}

void
print_recordlist(recordlist)
	RecordList     *recordlist;
{
	RecordList     *dp_tail;

	dp_tail = recordlist;
	fprintf(stdout, "PTR of BEGIN            : %x\n", dp_tail);

	while (dp_tail != RECNULL) {
		fprintf(stdout, "   PTR of octets        : %x\n", dp_tail->record.octets);
		aux_xdump(dp_tail->record.octets, dp_tail->record.noctets, 0);
		dp_tail = dp_tail->next;
		fprintf(stdout, "PTR of NEXT             : %x\n", dp_tail);
	};
}

void
print_keydevpurpose(key_dev_purpose)
	KeyDevPurpose  *key_dev_purpose;
{
	if (!key_dev_purpose)
		fprintf(stdout, "KeyDevPurpose           : NULL\n");
	else {
		fprintf(stdout, "KeyDevPurpose           : \n");
		fprintf(stdout, "    key_purpose         : \n");
		switch (key_dev_purpose->key_purpose.authenticate) {
		case TRUE:
			fprintf(stdout, "        authenticate    : TRUE\n");
			break;
		case FALSE:
			fprintf(stdout, "        authenticate    : FALSE\n");
			break;
		default:
			fprintf(stdout, "        authenticate    : undefined\n");
			break;
		}
		switch (key_dev_purpose->key_purpose.sec_mess_auth) {
		case TRUE:
			fprintf(stdout, "        sec_mess_auth   : TRUE\n");
			break;
		case FALSE:
			fprintf(stdout, "        sec_mess_auth   : FALSE\n");
			break;
		default:
			fprintf(stdout, "        sec_mess_auth   : undefined\n");
			break;
		}

		switch (key_dev_purpose->key_purpose.sec_mess_con) {
		case TRUE:
			fprintf(stdout, "        sec_mess_con    : TRUE\n");
			break;
		case FALSE:
			fprintf(stdout, "        sec_mess_conc   : FALSE\n");
			break;
		default:
			fprintf(stdout, "        sec_mess_conc   : undefined\n");
			break;
		}
		fprintf(stdout, "        cipherment      : is not used for a device key\n");

		if (key_dev_purpose->key_dev_status == DEV_ANY)
			fprintf(stdout, "    key_dev_status      : DEV_ANY\n");
		else
			fprintf(stdout, "    key_dev_status      : value not allowed\n");

		if (key_dev_purpose->key_type == MASTER)
			fprintf(stdout, "    key_type            : MASTER\n");
		else
			fprintf(stdout, "    key_type            : value not supported\n");





	}			/* key_dev_purpose <> NULL */

}

void
print_keydevsel(key_dev_sel)
	KeyDevSel      *key_dev_sel;
{
	if (!key_dev_sel)
		fprintf(stdout, "KeyDevSEL               : NULL\n");
	else {
		fprintf(stdout, "KeyDevSel               : \n");
		switch (key_dev_sel->key_status) {
		case DEV_OWN:
			fprintf(stdout, "        key_status      : DEV_OWN\n");
			break;
		case DEV_ANY:
			fprintf(stdout, "        key_status      : DEV_ANY\n");
			break;
		default:
			fprintf(stdout, "        key_status      : undefined\n");
			break;
		}

		if (key_dev_sel->key_status == DEV_ANY)
			print_keyid(&key_dev_sel->dev_ref.key_id);
		else {
			fprintf(stdout, "    key_purpose         : \n");
			switch (key_dev_sel->dev_ref.key_purpose.authenticate) {
			case TRUE:
				fprintf(stdout, "        authenticate    : TRUE\n");
				break;
			case FALSE:
				fprintf(stdout, "        authenticate    : FALSE\n");
				break;
			default:
				fprintf(stdout, "        authenticate    : undefined\n");
				break;
			}
			switch (key_dev_sel->dev_ref.key_purpose.sec_mess_auth) {
			case TRUE:
				fprintf(stdout, "        sec_mess_auth   : TRUE\n");
				break;
			case FALSE:
				fprintf(stdout, "        sec_mess_auth   : FALSE\n");
				break;
			default:
				fprintf(stdout, "        sec_mess_auth   : undefined\n");
				break;
			}

			switch (key_dev_sel->dev_ref.key_purpose.sec_mess_con) {
			case TRUE:
				fprintf(stdout, "        sec_mess_con    : TRUE\n");
				break;
			case FALSE:
				fprintf(stdout, "        sec_mess_conc   : FALSE\n");
				break;
			default:
				fprintf(stdout, "        sec_mess_conc   : undefined\n");
				break;
			}
			fprintf(stdout, "        cipherment      : is not used for a device key\n");
		}

	}			/* key_dev_sel <> NULL */

}


void
print_keyattrlist(key_attr_list)
	KeyAttrList    *key_attr_list;
{
	if (!key_attr_list)
		fprintf(stdout, "KeyAttrList             : NULL\n");
	else {
		fprintf(stdout, "KeyAttrList             : \n");
		switch (key_attr_list->key_inst_mode) {
		case INST:
			fprintf(stdout, "    key_inst_mode       : INST\n");
			break;
		case REPL:
			fprintf(stdout, "    key_inst_mode       : REPL\n");
			break;
		default:
			fprintf(stdout, "    key_inst_mode       : undefined\n");
			break;
		}

		fprintf(stdout, "    key_attr            : \n");
		fprintf(stdout, "       key_purpose      : \n");
		switch (key_attr_list->key_attr.key_purpose.authenticate) {
		case TRUE:
			fprintf(stdout, "        authenticate    : TRUE\n");
			break;
		case FALSE:
			fprintf(stdout, "        authenticate    : FALSE\n");
			break;
		default:
			fprintf(stdout, "        authenticate    : undefined\n");
			break;
		}
		switch (key_attr_list->key_attr.key_purpose.sec_mess_auth) {
		case TRUE:
			fprintf(stdout, "        sec_mess_auth   : TRUE\n");
			break;
		case FALSE:
			fprintf(stdout, "        sec_mess_auth   : FALSE\n");
			break;
		default:
			fprintf(stdout, "        sec_mess_auth   : undefined\n");
			break;
		}

		switch (key_attr_list->key_attr.key_purpose.sec_mess_con) {
		case TRUE:
			fprintf(stdout, "        sec_mess_con    : TRUE\n");
			break;
		case FALSE:
			fprintf(stdout, "        sec_mess_conc   : FALSE\n");
			break;
		default:
			fprintf(stdout, "        sec_mess_conc   : undefined\n");
			break;
		}

		switch (key_attr_list->key_attr.key_purpose.cipherment) {
		case TRUE:
			fprintf(stdout, "        cipherment      : TRUE\n");
			break;
		case FALSE:
			fprintf(stdout, "        cipherment      : FALSE\n");
			break;
		default:
			fprintf(stdout, "        cipherment      : undefined\n");
			break;
		}

		switch (key_attr_list->key_attr.key_presentation) {
		case KEY_GLOBAL:
			fprintf(stdout, "       key_presenation  : KEY_GLOBAL\n");
			break;
		case KEY_LOCAL:
			fprintf(stdout, "       key_presenation  : KEY_LOCAL\n");
			break;
		default:
			fprintf(stdout, "       key_presenation  : value not defined\n");
			break;
		}

		switch (key_attr_list->key_attr.key_op_mode) {
		case REPLACE:
			fprintf(stdout, "       key_op_mode      : REPLACE\n");
			break;
		case NO_REPLACE:
			fprintf(stdout, "       key_op_mode      : NO_REPLACE\n");
			break;
		default:
			fprintf(stdout, "       key_op_mode      : value not defined\n");
			break;
		}



		fprintf(stdout, "       MAC_length       : %d\n",
			key_attr_list->key_attr.MAC_length);

		fprintf(stdout, "    key_fpc             : %d\n", key_attr_list->key_fpc);

		fprintf(stdout, "    key_status          : \n");
		switch (key_attr_list->key_status.PIN_check) {
		case TRUE:
			fprintf(stdout, "       PIN_check        : TRUE\n");
			break;
		case FALSE:
			fprintf(stdout, "       PIN_check        : FALSE\n");
			break;
		default:
			fprintf(stdout, "       PIN_check        : value not defined\n");
			break;
		}

		switch (key_attr_list->key_status.key_state) {
		case KEY_NORMAL:
			fprintf(stdout, "       key_state        : KEY_NORMAL\n");
			break;
		case KEY_LOCKED:
			fprintf(stdout, "       key_state        : KEY_LOCKED\n");
			break;
		default:
			fprintf(stdout, "       key_state        : value not defined\n");
			break;
		}

	}


}

void
print_pinstruc(pin)
	PINStruc       *pin;
{
	if (!pin)
		fprintf(stdout, "PINStruc                : NULL\n");
	else {
		fprintf(stdout, "PINStruc                : \n");
		switch (pin->pin_type) {
		case PIN:
			fprintf(stdout, "    pin_type            : PIN\n");
			fprintf(stdout, "    pin_info            :\n");
			fprintf(stdout, "       min_len          : %d\n",
				pin->PINBody.pin_info.min_len);
			if (!pin->PINBody.pin_info.pin)
				fprintf(stdout, "       pin              : NULL\n");
			else
				fprintf(stdout, "       pin              : %s\n",
					pin->PINBody.pin_info.pin);
			if (!pin->PINBody.pin_info.clear_pin)
				fprintf(stdout, "       clear_pin        : NULL\n");
			else
				fprintf(stdout, "       clear_pin        : %s\n",
					pin->PINBody.pin_info.clear_pin);


			break;
		case PUK:
			fprintf(stdout, "    pin_type            : PUK\n");
			fprintf(stdout, "    puk_info            :\n");
			if (!pin->PINBody.puk_info.puk)
				fprintf(stdout, "       puk              : NULL\n");
			else
				fprintf(stdout, "       pin              : %s\n",
					pin->PINBody.puk_info.puk);

			fprintf(stdout, "       PIN_key_id       :\n");
			switch (pin->PINBody.puk_info.pin_key_id.key_level) {
			case SC_MF:
				fprintf(stdout, "          key_level     : SC_MF\n");
				break;
			case SC_DF:
				fprintf(stdout, "          key_level     : SC_DF\n");
				break;
			case SC_SF:
				fprintf(stdout, "          key_level     : SC_SF\n");
				break;
			default:
				fprintf(stdout, "          key_level     : value not allowed\n");
				break;
			};

			fprintf(stdout, "          key_number    : %d\n",
				pin->PINBody.puk_info.pin_key_id.key_number);
			break;
		default:
			fprintf(stdout, "    pin_type            : value not defined\n");
			break;
		}
	}
}

void
print_keydevlist(key_dev_list)
	KeyDevList     *key_dev_list;
{

	if (!key_dev_list)
		fprintf(stdout, "KeyDevList              : NULL\n");
	else {
		fprintf(stdout, "KeyDevList              : \n");
		fprintf(stdout, "auth_key                : \n");
		print_keyid(key_dev_list->auth_key);
		fprintf(stdout, "sec_auth_key            : \n");
		print_keyid(key_dev_list->sec_auth_key);
		fprintf(stdout, "sec_con_key             : \n");
		print_keyid(key_dev_list->sec_con_key);
	}
}

#endif



/*-------------------------------------------------------------*/
/* E N D   O F	 P A C K A G E	     STAMOD-staprint	       */
/*-------------------------------------------------------------*/