[mirror_frr.git] / isisd / isis_pdu.h

/*
 * IS-IS Rout(e)ing protocol - isis_pdu.h
 *                             PDU processing
 *
 * Copyright (C) 2001,2002   Sampo Saaristo
 *                           Tampere University of Technology      
 *                           Institute of Communications Engineering
 *
 * This program is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU General Public Licenseas published by the Free 
 * Software Foundation; either version 2 of the License, or (at your option) 
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,but WITHOUT 
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
 * more details.

 * You should have received a copy of the GNU General Public License along 
 * with this program; if not, write to the Free Software Foundation, Inc., 
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifndef _ZEBRA_ISIS_PDU_H
#define _ZEBRA_ISIS_PDU_H

#ifdef __SUNPRO_C
#pragma pack(1)
#endif

/*
 *                    ISO 9542 - 7.5,7.6
 *
 *                       ES to IS Fixed Header
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |         Intradomain Routeing Protocol Discriminator           |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                       Length Indicator                        |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                  Version/Protocol ID extension                |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                         Reserved = 0                          |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |   0   |   0   |   0   |              PDU Type                 |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                         Holding Time                          | 2
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                          Checksum                             | 2
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 */

struct esis_fixed_hdr
{
  u_char idrp;
  u_char length;
  u_char version;
  u_char id_len;
  u_char pdu_type;
  u_int16_t holdtime;
  u_int16_t checksum;
} __attribute__ ((packed));

#define ESIS_FIXED_HDR_LEN   9

#define ESH_PDU              2
#define ISH_PDU              4
#define RD_PDU               5

/*
 *                       IS to IS Fixed Header
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |         Intradomain Routeing Protocol Discriminator           | 
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                       Length Indicator                        |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                  Version/Protocol ID extension                |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |   R   |   R   |   R   |              PDU Type                 |      
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                            Version                            |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                            Reserved                           |
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 *  |                       Maximum Area Addresses                  |      
 *  +-------+-------+-------+-------+-------+-------+-------+-------+
 */

struct isis_fixed_hdr
{
  u_char idrp;
  u_char length;
  u_char version1;
  u_char id_len;
  u_char pdu_type;
  u_char version2;
  u_char reserved;
  u_char max_area_addrs;
} __attribute__ ((packed));

#define ISIS_FIXED_HDR_LEN 8

/*
 * IS-IS PDU types.
 */

#define L1_LAN_HELLO         15
#define L2_LAN_HELLO         16
/*
 *              L1 and L2 LAN IS to IS Hello PDU header
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |                       Reserved                | Circuit Type  | 1
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Source ID                              + id_len   
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |                        Holding  Time                          | 2     
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |                        PDU Length                             | 2    
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |   R   |                Priority                               | 1
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |                        LAN ID                                 | id_len + 1
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 */
struct isis_lan_hello_hdr
{
  u_char circuit_t;
  u_char source_id[ISIS_SYS_ID_LEN];
  u_int16_t hold_time;
  u_int16_t pdu_len;
  u_char prio;
  u_char lan_id[ISIS_SYS_ID_LEN + 1];
} __attribute__ ((packed));
#define ISIS_LANHELLO_HDRLEN  19

#define P2P_HELLO            17
/*
 *           Point-to-point IS to IS hello PDU header
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |                        Reserved               | Circuit Type  | 1
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Source ID                              + id_len   
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Holding  Time                          + 2     
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        PDU Length                             + 2    
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |                        Local Circuit ID                       | 1
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 */
struct isis_p2p_hello_hdr
{
  u_char circuit_t;
  u_char source_id[ISIS_SYS_ID_LEN];
  u_int16_t hold_time;
  u_int16_t pdu_len;
  u_char local_id;
} __attribute__ ((packed));
#define ISIS_P2PHELLO_HDRLEN 12

#define L1_LINK_STATE        18
#define L2_LINK_STATE        20
/*
 *              L1 and L2 IS to IS link state PDU header
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        PDU Length                             + 2
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Remaining Lifetime                     + 2 
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |                        LSP ID                                 | id_len + 2
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Sequence Number                        + 4
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Checksum                               + 2
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * |   P   |              ATT              |LSPDBOL|    ISTYPE     |
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 */
struct isis_link_state_hdr
{
  u_int16_t pdu_len;
  u_int16_t rem_lifetime;
  u_char lsp_id[ISIS_SYS_ID_LEN + 2];
  u_int32_t seq_num;
  u_int16_t checksum;
  u_int8_t lsp_bits;
} __attribute__ ((packed));
#define ISIS_LSP_HDR_LEN 19

/*
 * Since the length field of LSP Entries TLV is one byte long, and each LSP
 * entry is LSP_ENTRIES_LEN (16) bytes long, the maximum number of LSP entries
 * can be accomodated in a TLV is
 * 255 / 16 = 15.
 * 
 * Therefore, the maximum length of the LSP Entries TLV is
 * 16 * 15 + 2 (header) = 242 bytes.
 */
#define MAX_LSP_ENTRIES_TLV_SIZE 242

#define L1_COMPLETE_SEQ_NUM  24
#define L2_COMPLETE_SEQ_NUM  25
/*
 *      L1 and L2 IS to IS complete sequence numbers PDU header
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        PDU Length                             + 2    
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Source ID                              + id_len + 1
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Start LSP ID                           + id_len + 2
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        End LSP ID                             + id_len + 2
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 */
struct isis_complete_seqnum_hdr
{
  u_int16_t pdu_len;
  u_char source_id[ISIS_SYS_ID_LEN + 1];
  u_char start_lsp_id[ISIS_SYS_ID_LEN + 2];
  u_char stop_lsp_id[ISIS_SYS_ID_LEN + 2];
};
#define ISIS_CSNP_HDRLEN 25

#define L1_PARTIAL_SEQ_NUM   26
#define L2_PARTIAL_SEQ_NUM   27
/*
 *      L1 and L2 IS to IS partial sequence numbers PDU header
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        PDU Length                             + 2
 * +-------+-------+-------+-------+-------+-------+-------+-------+
 * +                        Source ID                              + id_len + 1
 * +---------------------------------------------------------------+
 */
struct isis_partial_seqnum_hdr
{
  u_int16_t pdu_len;
  u_char source_id[ISIS_SYS_ID_LEN + 1];
};
#define ISIS_PSNP_HDRLEN 9

#ifdef __SUNPRO_C
#pragma pack()
#endif

/*
 * Function for receiving IS-IS PDUs
 */
int isis_receive (struct thread *thread);

/*
 * calling arguments for snp_process ()
 */
#define ISIS_SNP_PSNP_FLAG 0
#define ISIS_SNP_CSNP_FLAG 1

#define ISIS_AUTH_MD5_SIZE       16U

/*
 * Sending functions
 */
int send_lan_l1_hello (struct thread *thread);
int send_lan_l2_hello (struct thread *thread);
int send_p2p_hello (struct thread *thread);
int send_csnp (struct isis_circuit *circuit, int level);
int send_l1_csnp (struct thread *thread);
int send_l2_csnp (struct thread *thread);
int send_l1_psnp (struct thread *thread);
int send_l2_psnp (struct thread *thread);
int send_lsp (struct thread *thread);
int ack_lsp (struct isis_link_state_hdr *hdr,
	     struct isis_circuit *circuit, int level);
void fill_fixed_hdr (struct isis_fixed_hdr *hdr, u_char pdu_type);
int send_hello (struct isis_circuit *circuit, int level);

#endif /* _ZEBRA_ISIS_PDU_H */
Commit	Line	Data
eb5d44eb	1	/*
	2	* IS-IS Rout(e)ing protocol - isis_pdu.h
	3	* PDU processing
	4	*
	5	* Copyright (C) 2001,2002 Sampo Saaristo
	6	* Tampere University of Technology
	7	* Institute of Communications Engineering
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public Licenseas published by the Free
	11	* Software Foundation; either version 2 of the License, or (at your option)
	12	* any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,but WITHOUT
	15	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	16	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	17	* more details.
	18
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	22	*/
	23
	24	#ifndef _ZEBRA_ISIS_PDU_H
	25	#define _ZEBRA_ISIS_PDU_H
	26
238497fc PJ	27	#ifdef __SUNPRO_C
	28	#pragma pack(1)
	29	#endif
	30
eb5d44eb	31	/*
	32	* ISO 9542 - 7.5,7.6
	33	*
	34	* ES to IS Fixed Header
	35	* +-------+-------+-------+-------+-------+-------+-------+-------+
	36	* \| Intradomain Routeing Protocol Discriminator \|
	37	* +-------+-------+-------+-------+-------+-------+-------+-------+
	38	* \| Length Indicator \|
	39	* +-------+-------+-------+-------+-------+-------+-------+-------+
	40	* \| Version/Protocol ID extension \|
	41	* +-------+-------+-------+-------+-------+-------+-------+-------+
	42	* \| Reserved = 0 \|
	43	* +-------+-------+-------+-------+-------+-------+-------+-------+
	44	* \| 0 \| 0 \| 0 \| PDU Type \|
	45	* +-------+-------+-------+-------+-------+-------+-------+-------+
	46	* \| Holding Time \| 2
	47	* +-------+-------+-------+-------+-------+-------+-------+-------+
	48	* \| Checksum \| 2
	49	* +-------+-------+-------+-------+-------+-------+-------+-------+
	50	*/
	51
	52	struct esis_fixed_hdr
	53	{
	54	u_char idrp;
	55	u_char length;
	56	u_char version;
	57	u_char id_len;
	58	u_char pdu_type;
	59	u_int16_t holdtime;
	60	u_int16_t checksum;
f390d2c7	61	} __attribute__ ((packed));
eb5d44eb	62
	63	#define ESIS_FIXED_HDR_LEN 9
	64
	65	#define ESH_PDU 2
	66	#define ISH_PDU 4
	67	#define RD_PDU 5
	68
	69	/*
	70	* IS to IS Fixed Header
	71	* +-------+-------+-------+-------+-------+-------+-------+-------+
	72	* \| Intradomain Routeing Protocol Discriminator \|
	73	* +-------+-------+-------+-------+-------+-------+-------+-------+
	74	* \| Length Indicator \|
	75	* +-------+-------+-------+-------+-------+-------+-------+-------+
	76	* \| Version/Protocol ID extension \|
	77	* +-------+-------+-------+-------+-------+-------+-------+-------+
	78	* \| R \| R \| R \| PDU Type \|
	79	* +-------+-------+-------+-------+-------+-------+-------+-------+
	80	* \| Version \|
	81	* +-------+-------+-------+-------+-------+-------+-------+-------+
	82	* \| Reserved \|
	83	* +-------+-------+-------+-------+-------+-------+-------+-------+
	84	* \| Maximum Area Addresses \|
	85	* +-------+-------+-------+-------+-------+-------+-------+-------+
	86	*/
	87
f390d2c7	88	struct isis_fixed_hdr
eb5d44eb	89	{
	90	u_char idrp;
	91	u_char length;
	92	u_char version1;
	93	u_char id_len;
	94	u_char pdu_type;
	95	u_char version2;
	96	u_char reserved;
	97	u_char max_area_addrs;
3f045a08	98	} __attribute__ ((packed));
eb5d44eb	99
	100	#define ISIS_FIXED_HDR_LEN 8
	101
	102	/*
	103	* IS-IS PDU types.
	104	*/
	105
	106	#define L1_LAN_HELLO 15
	107	#define L2_LAN_HELLO 16
	108	/*
	109	* L1 and L2 LAN IS to IS Hello PDU header
	110	* +-------+-------+-------+-------+-------+-------+-------+-------+
	111	* \| Reserved \| Circuit Type \| 1
	112	* +-------+-------+-------+-------+-------+-------+-------+-------+
	113	* + Source ID + id_len
	114	* +-------+-------+-------+-------+-------+-------+-------+-------+
	115	* \| Holding Time \| 2
	116	* +-------+-------+-------+-------+-------+-------+-------+-------+
e38e0df0	117	* \| PDU Length \| 2
eb5d44eb	118	* +-------+-------+-------+-------+-------+-------+-------+-------+
	119	* \| R \| Priority \| 1
	120	* +-------+-------+-------+-------+-------+-------+-------+-------+
	121	* \| LAN ID \| id_len + 1
	122	* +-------+-------+-------+-------+-------+-------+-------+-------+
	123	*/
f390d2c7	124	struct isis_lan_hello_hdr
	125	{
	126	u_char circuit_t;
	127	u_char source_id[ISIS_SYS_ID_LEN];
	128	u_int16_t hold_time;
	129	u_int16_t pdu_len;
	130	u_char prio;
	131	u_char lan_id[ISIS_SYS_ID_LEN + 1];
	132	} __attribute__ ((packed));
eb5d44eb	133	#define ISIS_LANHELLO_HDRLEN 19
	134
	135	#define P2P_HELLO 17
	136	/*
	137	* Point-to-point IS to IS hello PDU header
	138	* +-------+-------+-------+-------+-------+-------+-------+-------+
	139	* \| Reserved \| Circuit Type \| 1
	140	* +-------+-------+-------+-------+-------+-------+-------+-------+
	141	* + Source ID + id_len
	142	* +-------+-------+-------+-------+-------+-------+-------+-------+
	143	* + Holding Time + 2
	144	* +-------+-------+-------+-------+-------+-------+-------+-------+
e38e0df0	145	* + PDU Length + 2
eb5d44eb	146	* +-------+-------+-------+-------+-------+-------+-------+-------+
	147	* \| Local Circuit ID \| 1
	148	* +-------+-------+-------+-------+-------+-------+-------+-------+
	149	*/
f390d2c7	150	struct isis_p2p_hello_hdr
	151	{
	152	u_char circuit_t;
	153	u_char source_id[ISIS_SYS_ID_LEN];
	154	u_int16_t hold_time;
	155	u_int16_t pdu_len;
eb5d44eb	156	u_char local_id;
f390d2c7	157	} __attribute__ ((packed));
eb5d44eb	158	#define ISIS_P2PHELLO_HDRLEN 12
	159
	160	#define L1_LINK_STATE 18
	161	#define L2_LINK_STATE 20
	162	/*
	163	* L1 and L2 IS to IS link state PDU header
	164	* +-------+-------+-------+-------+-------+-------+-------+-------+
	165	* + PDU Length + 2
	166	* +-------+-------+-------+-------+-------+-------+-------+-------+
	167	* + Remaining Lifetime + 2
	168	* +-------+-------+-------+-------+-------+-------+-------+-------+
	169	* \| LSP ID \| id_len + 2
	170	* +-------+-------+-------+-------+-------+-------+-------+-------+
	171	* + Sequence Number + 4
	172	* +-------+-------+-------+-------+-------+-------+-------+-------+
	173	* + Checksum + 2
	174	* +-------+-------+-------+-------+-------+-------+-------+-------+
	175	* \| P \| ATT \|LSPDBOL\| ISTYPE \|
	176	* +-------+-------+-------+-------+-------+-------+-------+-------+
	177	*/
f390d2c7	178	struct isis_link_state_hdr
	179	{
	180	u_int16_t pdu_len;
eb5d44eb	181	u_int16_t rem_lifetime;
f390d2c7	182	u_char lsp_id[ISIS_SYS_ID_LEN + 2];
eb5d44eb	183	u_int32_t seq_num;
eb5d44eb	184	u_int16_t checksum;
f390d2c7	185	u_int8_t lsp_bits;
f390d2c7	186	} __attribute__ ((packed));
eb5d44eb	187	#define ISIS_LSP_HDR_LEN 19
eb5d44eb	188
3f045a08 JB	189	/*
	190	* Since the length field of LSP Entries TLV is one byte long, and each LSP
	191	* entry is LSP_ENTRIES_LEN (16) bytes long, the maximum number of LSP entries
	192	* can be accomodated in a TLV is
	193	* 255 / 16 = 15.
	194	*
	195	* Therefore, the maximum length of the LSP Entries TLV is
	196	* 16 * 15 + 2 (header) = 242 bytes.
	197	*/
	198	#define MAX_LSP_ENTRIES_TLV_SIZE 242
	199
eb5d44eb	200	#define L1_COMPLETE_SEQ_NUM 24
	201	#define L2_COMPLETE_SEQ_NUM 25
	202	/*
	203	* L1 and L2 IS to IS complete sequence numbers PDU header
	204	* +-------+-------+-------+-------+-------+-------+-------+-------+
e38e0df0	205	* + PDU Length + 2
eb5d44eb	206	* +-------+-------+-------+-------+-------+-------+-------+-------+
	207	* + Source ID + id_len + 1
	208	* +-------+-------+-------+-------+-------+-------+-------+-------+
	209	* + Start LSP ID + id_len + 2
	210	* +-------+-------+-------+-------+-------+-------+-------+-------+
	211	* + End LSP ID + id_len + 2
	212	* +-------+-------+-------+-------+-------+-------+-------+-------+
	213	*/
f390d2c7	214	struct isis_complete_seqnum_hdr
f390d2c7	215	{
eb5d44eb	216	u_int16_t pdu_len;
f390d2c7	217	u_char source_id[ISIS_SYS_ID_LEN + 1];
	218	u_char start_lsp_id[ISIS_SYS_ID_LEN + 2];
	219	u_char stop_lsp_id[ISIS_SYS_ID_LEN + 2];
eb5d44eb	220	};
	221	#define ISIS_CSNP_HDRLEN 25
	222
	223	#define L1_PARTIAL_SEQ_NUM 26
	224	#define L2_PARTIAL_SEQ_NUM 27
	225	/*
	226	* L1 and L2 IS to IS partial sequence numbers PDU header
	227	* +-------+-------+-------+-------+-------+-------+-------+-------+
	228	* + PDU Length + 2
	229	* +-------+-------+-------+-------+-------+-------+-------+-------+
	230	* + Source ID + id_len + 1
	231	* +---------------------------------------------------------------+
	232	*/
f390d2c7	233	struct isis_partial_seqnum_hdr
f390d2c7	234	{
eb5d44eb	235	u_int16_t pdu_len;
f390d2c7	236	u_char source_id[ISIS_SYS_ID_LEN + 1];
eb5d44eb	237	};
	238	#define ISIS_PSNP_HDRLEN 9
	239
238497fc PJ	240	#ifdef __SUNPRO_C
	241	#pragma pack()
	242	#endif
	243
eb5d44eb	244	/*
	245	* Function for receiving IS-IS PDUs
	246	*/
	247	int isis_receive (struct thread *thread);
	248
	249	/*
	250	* calling arguments for snp_process ()
	251	*/
	252	#define ISIS_SNP_PSNP_FLAG 0
	253	#define ISIS_SNP_CSNP_FLAG 1
	254
3f045a08 JB	255	#define ISIS_AUTH_MD5_SIZE 16U
3f045a08 JB	256
eb5d44eb	257	/*
	258	* Sending functions
	259	*/
f390d2c7	260	int send_lan_l1_hello (struct thread *thread);
	261	int send_lan_l2_hello (struct thread *thread);
	262	int send_p2p_hello (struct thread *thread);
	263	int send_csnp (struct isis_circuit *circuit, int level);
	264	int send_l1_csnp (struct thread *thread);
	265	int send_l2_csnp (struct thread *thread);
	266	int send_l1_psnp (struct thread *thread);
	267	int send_l2_psnp (struct thread *thread);
	268	int send_lsp (struct thread *thread);
	269	int ack_lsp (struct isis_link_state_hdr *hdr,
	270	struct isis_circuit *circuit, int level);
	271	void fill_fixed_hdr (struct isis_fixed_hdr *hdr, u_char pdu_type);
	272	int send_hello (struct isis_circuit *circuit, int level);
eb5d44eb	273
eb5d44eb	274	#endif /* _ZEBRA_ISIS_PDU_H */