nsmib.h

包括ＥＰＡ协议栈

#ifndef _NSMIB_H
#define _NSMIB_H

#include "global.h"

#ifdef NSMIB_GLOBALS
	#define NSMIB_EXTERN
#else
	#define NSMIB_EXTERN extern
#endif	// MIB_EXTERN

#define NSMIB_BASE_OBJID_MIBHDR         (10)
#define	NSMIB_BASE_OBJID_KEY_MAN        (8001)
#define	NSMIB_BASE_OBJID_SEC_MEASURE    (8002)
#define	NSMIB_BASE_OBJID_PTCL_MAN       (8003)
#define	NSMIB_BASE_OBJID_AUTHEN         (8004)
#define NSMIB_BASE_OBJID_ACCTRL_OBJ     (8500)

#define MIB_NUM_ACCTRL_OBJ              (5)

#define NS_SEC_ID_LEN                   (32)
#define NS_SEC_KEY_LEN                  (32)
#define NS_SEC_KEY_TBL_LEN              (64)

typedef uint8 SECKeyTbl[NS_SEC_KEY_TBL_LEN];

typedef struct {
	uint16       obj_id;
	uint16       revision;
	uint16       num_sec_measeure;
	uint16       total_sec_measeure;
	uint16       obj_id_key_man;
	uint16       obj_id_sec_man;
	uint16       obj_id_pctl_man;
	uint16       obj_id_authen;
	uint16       first_acctrl_obj;
	uint16       num_acctrl_obj;
} NSMIBHdr, *PNSMIBHdr;

typedef struct {
	uint16       obj_id;
	uint16       revision;
	SECKeyTbl    key_tbl;
	uint16       key_off;
	uint16       key_len;
	Octet        pub_key[NS_SEC_KEY_LEN];
	Octet        prv_key[NS_SEC_KEY_LEN];
} KeyMan, *PKeyMan;

typedef struct {
	uint16       obj_id;
	uint16       revision;
	uint8        sec_mode;
	uint8        authen_mode;
	uint8        encypt_mode;
} SecMeasure, *PSecMeasure;

typedef struct {
	uint16       obj_id;
	uint16       revision;
	uint16       time_limit;
	uint8        run_mode;
	uint8        link_mode;
	uint8        authen_mode;
	uint8        Ptcl_type;
} SecPtclMan, *PSecPtclMan;

typedef struct {
	uint16       obj_id;
	uint16       revision;
	Octet        sec_id[NS_SEC_ID_LEN];
	Time         stamp;
	uint8        state;
} AuthenObj, *PAuthenObj;

typedef struct {
	uint16       obj_id;
	uint16       local_app;
	uint16       local_obj;
	uint16       rmt_app;
	uint16       rmt_obj;
	uint8        srv_op;
	uint8        srv_role;
	uint32       rmt_ip;
	TimeDiff     send_time_offset;
	uint8        right;
	uint8        group;
	uint16       psw;
} ACCtrlObj, *PACCtrlObj;

NSMIB_EXTERN NSMIBHdr      gns_mib_hdr;
NSMIB_EXTERN KeyMan        gns_key_man;
NSMIB_EXTERN SecMeasure    gns_sec_measure;
NSMIB_EXTERN SecPtclMan    gns_sec_ptcl_man;
NSMIB_EXTERN AuthenObj     gns_authen_obj;

#if MIB_NUM_ACCTRL_OBJ > 0
NSMIB_EXTERN ACCtrlObj     gns_acctrl_obj[MIB_NUM_ACCTRL_OBJ];
#endif	// MIB_NUM_ACCTRL_OBJ

/*----------------------------------------------------------------------------------*
 *- Get & Set Interface of Authen Object
 *----------------------------------------------------------------------------------*/
__inline void GetSecID(OctetString secid) {
	memcpy(secid, gns_authen_obj.sec_id, 32);
}

/*----------------------------------------------------------------------------------*
 *- Get & Set Interface of Acctrl Object
 *----------------------------------------------------------------------------------*/
__inline PACCtrlObj GetACCtrlObj(uint16 local_app, uint16 local_obj, uint16 rmt_app, uint16 rmt_obj) {
	uint16 idx;
	
	for(idx = 0; idx < MIB_NUM_ACCTRL_OBJ; ++idx) {
		if(gns_acctrl_obj[idx].local_app == local_app &&
			 gns_acctrl_obj[idx].local_obj == local_obj &&
			 gns_acctrl_obj[idx].rmt_app == rmt_app) {
			 	return (&gns_acctrl_obj[idx]);
			}
	}
	return (0);
}

__inline void SetLocalACCtrlOP(PACCtrlObj pacc_obj, uint8 op) {
	
	pacc_obj->srv_op = op;
}

/*----------------------------------------------------------------------------------*
 *- Get & Set Interface of Acctrl Object
 *----------------------------------------------------------------------------------*/
__inline uint8 GetSecMode(void) {
	return (gns_sec_measure.sec_mode);
}

/*----------------------------------------------------------------------------------*
 *- Read & Write Interface of objects
 *----------------------------------------------------------------------------------*/
void NSMIBHdr_Init(void);

__inline uint8 NSMIBHdr_Read(uint16 idx, uint16 msg_id, uint16 src_app, uint16 src_port, uint32 src_ip) {
	OctetString payload;
	
	switch (idx) {
		case 0:
			h2n16(gns_mib_hdr.obj_id, payload);
			h2n16(gns_mib_hdr.revision, payload + 2);
			h2n16(gns_mib_hdr.num_sec_measeure, payload + 4);
			h2n16(gns_mib_hdr.total_sec_measeure, payload + 6);
			h2n16(gns_mib_hdr.obj_id_key_man, payload + 8);
			h2n16(gns_mib_hdr.obj_id_sec_man, payload + 10);
			h2n16(gns_mib_hdr.obj_id_pctl_man, payload + 12);
			h2n16(gns_mib_hdr.obj_id_authen, payload + 14);
			h2n16(gns_mib_hdr.first_acctrl_obj, payload + 16);
			h2n16(gns_mib_hdr.num_acctrl_obj, payload + 18);
			Read_Pos_Output(src_app, payload, 20, msg_id, src_port, src_ip);
			break;
		case 2:
			h2n16(gns_mib_hdr.revision, payload + 2);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 3:
			h2n16(gns_mib_hdr.num_sec_measeure, payload + 2);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 4:
			h2n16(gns_mib_hdr.total_sec_measeure, payload + 2);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 5:
			h2n16(gns_mib_hdr.obj_id_key_man, payload + 2);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 6:
			h2n16(gns_mib_hdr.obj_id_sec_man, payload + 2);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 7:
			h2n16(gns_mib_hdr.obj_id_pctl_man, payload + 2);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 8:
			h2n16(gns_mib_hdr.obj_id_authen, payload + 2);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 9:
			h2n16(gns_mib_hdr.first_acctrl_obj, payload + 2);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 10:
			h2n16(gns_mib_hdr.num_acctrl_obj, payload);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		default:
			Read_Neg_Output(src_app, 1, 2, 0, msg_id, src_port, src_ip);
			return EPA_SUBINDEX_ILLEGAL;
	}
	return EPA_NO_ERR;
}

__inline uint8 NSMIBHdr_Write(uint16 idx, OctetString payload, uint16 msg_id, uint16 src_app, uint16 src_port, uint32 src_ip) {
	if(idx > 10) {
		Write_Neg_Output(src_app, 1, 2, 0, msg_id, src_port, src_ip);
		return EPA_SUBINDEX_ILLEGAL;
	}
	Write_Neg_Output(src_app, 1, 3, 0, msg_id, src_port, src_ip);
	return EPA_OBJ_UNWRITABLE;
}

void KeyMan_Init(void);

__inline uint8 KeyMan_Read(uint16 idx, uint16 msg_id, uint16 src_app, uint16 src_port, uint32 src_ip) {
	OctetString payload;
	
	switch (idx) {
		case 0:
			h2n16(gns_key_man.obj_id, payload);
			h2n16(gns_key_man.revision, payload + 2);
			memcpy(payload + 4, gns_key_man.key_tbl, 64);
			h2n16(gns_key_man.key_off, payload + 68);
			h2n16(gns_key_man.key_len, payload + 70);
			memcpy(payload + 72, gns_key_man.pub_key, 32);
			memcpy(payload + 104, gns_key_man.prv_key, 32);
			Read_Pos_Output(src_app, payload, 136, msg_id, src_port, src_ip);
			break;
		case 2:
			h2n16(gns_key_man.revision, payload);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 3:
			memcpy(payload, gns_key_man.key_tbl, 64);
			Read_Pos_Output(src_app, payload, 64, msg_id, src_port, src_ip);
			break;
		case 4:
			h2n16(gns_key_man.key_off, payload);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 5:
			h2n16(gns_key_man.key_len, payload);
			Read_Pos_Output(src_app, payload, 16, msg_id, src_port, src_ip);
			break;
		case 6:
			memcpy(payload, gns_key_man.pub_key, 32);
			Read_Pos_Output(src_app, payload, 32, msg_id, src_port, src_ip);
			break;
		case 7:
			memcpy(payload, gns_key_man.prv_key, 32);
			Read_Pos_Output(src_app, payload, 32, msg_id, src_port, src_ip);
			break;
		default:
			Read_Neg_Output(src_app, 1, 2, 0, msg_id, src_port, src_ip);
			return EPA_SUBINDEX_ILLEGAL;
	}
	return EPA_NO_ERR;
}

__inline uint8 KeyMan_Write(uint16 idx, OctetString payload, uint16 msg_id, uint32 src_app, uint16 src_port, uint32 src_ip) {
	switch(idx) {
		case 0:
			memcpy(&gns_key_man.key_tbl, payload, 64);
			n2h16(payload, &gns_key_man.key_off);
			n2h16(payload, &gns_key_man.key_len);
			Write_Pos_Output(src_app, msg_id, src_port, src_ip);
			break;
		case 3:
			memcpy(&gns_key_man.key_tbl, payload, 64);
			Write_Pos_Output(src_app, msg_id, src_port, src_ip);
			break;
		case 4:
			n2h16(payload, &gns_key_man.key_off);
			Write_Pos_Output(src_app, msg_id, src_port, src_ip);
			break;
		case 5:
			n2h16(payload, &gns_key_man.key_len);
			Write_Pos_Output(src_app, msg_id, src_port, src_ip);
			break;
		default:
			if(idx > 7) {
				Write_Neg_Output(src_app, 1, 2, 0, msg_id, src_port, src_ip);
				return EPA_SUBINDEX_ILLEGAL;
			}
			Write_Neg_Output(src_app, 1, 3, 0, msg_id, src_port, src_ip);
			return EPA_OBJ_UNWRITABLE;
	}
	return EPA_NO_ERR;
}

void SecMeasure_Init(void);

__inline uint8 SecMeasure_Read(uint16 idx, uint16 msg_id, uint16 src_app, uint16 src_port, uint32 src_ip) {
	OctetString payload;
	
	switch (idx) {
		case 0:
			h2n16(gns_sec_measure.obj_id, payload);
			h2n16(gns_sec_measure.revision, payload + 2);
			payload[4] = gns_sec_measure.sec_mode;
			payload[5] = gns_sec_measure.authen_mode;
			payload[6] = gns_sec_measure.encypt_mode;
			Read_Pos_Output(src_app, payload, 7, msg_id, src_port, src_ip);
			break;
		case 2:
			h2n16(gns_sec_measure.obj_id, payload);
			Read_Pos_Output(src_app, payload, 2, msg_id, src_port, src_ip);
			break;
		case 3:
			payload[0] = gns_sec_measure.sec_mode;
			Read_Pos_Output(src_app, payload, 1, msg_id, src_port, src_ip);
			break;
		case 4:
			payload[0] = gns_sec_measure.authen_mode;
			Read_Pos_Output(src_app, payload, 1, msg_id, src_port, src_ip);
			break;
		case 5:
			payload[0] = gns_sec_measure.encypt_mode;
			Read_Pos_Output(src_app, payload, 1, msg_id, src_port, src_ip);
			break;
		default:
			Read_Neg_Output(src_app, 1, 2, 0, msg_id, src_port, src_ip);
			return EPA_SUBINDEX_ILLEGAL;
	}
	return EPA_NO_ERR;
}

__inline uint8 SecMeasure_Write(uint16 idx, OctetString payload, uint16 msg_id, uint16 src_app, uint16 src_port, uint32 src_ip) {
	switch (idx) {
		case 0:
			gns_sec_measure.sec_mode = payload[4];
			gns_sec_measure.authen_mode = payload[5];
			gns_sec_measure.encypt_mode = payload[6];
			Write_Pos_Output(src_app, msg_id, src_port, src_ip);
			break;
		case 3:
			gns_sec_measure.sec_mode = payload[0];
			Write_Pos_Output(src_app, msg_id, src_port, src_ip);