 




This document contains 
RouterWare, Inc. confidential 
information that is not to be 
disclosed without prior written 
authorization.















RouterWare, Inc.
3961 MacArthur Blvd., Suite 212
Newport Beach, CA 92660
(714) 442-0770






















CCP Overview
V1.03
October 19, 1995











Copyright O 1995, RouterWare, Inc.

Unauthorized use, duplication or distribution of this document is strictly prohibited.

RouterWare, Inc. makes no warranty for the use of this document and assumes no responsibility for any 
omissions and or errors which may be present.

RouterWare, Inc. retains the right to make changes to this document at any time, without notice.

All Rights Reserved

Permission to use, copy, modify, and distribute this documentation for any purpose is not permitted 
without the prior consent of RouterWare, Inc.


Revision History

Rev 1.00	First pass.  Needs further references.
Rev 1.01	Added references, function an file data, API functions, deleted registration stuff
Rev 1.02	Revised initialization prototype and API functions list
Rev 1.03	Added Stacker modification note and additional information concerning ccp.h file



OVERVIEW	5
HEADER FILES	6
CCP.H ORGANIZATION	6
SOURCE FILES	7
CONSTANTS AND ENUMS OF NOTE	8
CCP INTIALIZATION	9
INITIALIZE_CCP() FUNCTION PROTOTYPE	9
INITIALIZE_CCP() FUNCTION PARAMETERS	11
CCP FUNCTIONS REGISTERING INTO PPP	12
PPP FUNCTIONS REGISTERING INTO CCP	12
API FUNCTIONS ORGANIZATION	13
COMPRESSOR API	14
DECOMPRESSOR API	15
RESET REQUEST API	16
RESET ACK API	17
PPP .INI CONFIGURATION PARAMETERS	18
[[ PPP COMPRESSION = SECTION START ]]	18
PPP CCP = [ENABLED|DISABLED]	18
CCP .INI CONFIGURATION PARAMETERS	19
[[ CCP COMPRESSION = SECTION START ]]	19
CCP PORT = [WW], [ENABLED|DISABLED]	19
CCP PORT STACKER PERFORMANCE VALUE = [WW], [DECIMAL VALUE 0-255]	19
CCP PORT STACKER PERFORMANCE MODE =  [WW], [DECIMAL VALUE 0-2]	19
CCP PORT OPTION = [WW], CCP, [COMMA SEPARATED PARAMETERS]	19
CCP PORT REMOTE OPTION = [WW], CCP, [COMMA SEPARATED PARAMETERS]	19
CCP INITIALIZATION BREAKPOINT =  [ENABLED|DISABLED]	21
CCP RUN TIME BREAKPOINT =  [ENABLED|DISABLED]	21
CCP PRINTF CONTROL	21
PREDICTOR TYPE I OPTION NOTES	22
PREDICTOR TYPE II OPTION NOTES	22
STACKER LZS OPTION NOTES	22
BSD LZW OPTION NOTES	22
NOTES CONCERNING STAC ELECTRONICS LZS	23
REFERENCES	24



Overview

RouterWare Compression Control Protocol (CCP) version 1.00 is an implementation of the PPP 
Compression Control Protocol  Internet Draft  . It supports four compression protocols: Predictor  type 1, 
Predictor type 2, Stac Electronics LZS, and BSD LZW Compress. The implementations of the four 
compression algorithms are based on Internet Drafts for the PPP Predictor Compression Protocol  , PPP 
Stacker LZS Compression Protocol , and PPP BSD Compression Protocol  respectively.  RouterWare 
will update the implementation when newer versions of the drafts become available or when any of the 
drafts achieve RFC status.

RouterWare CCP is a layer between RouterWare PPP and the device driver layer. If CCP is disabled or no 
compression algorithm can be successfully negotiated in either direction, the CCP layer is completely 
bypassed and all the packets are sent and received uncompressed. Otherwise, all compressible PPP packets 
(i.e. packets won't cause compression expansion) will be compressed/decompressed inside this layer and 
the compression is thus transparent to both PPP and the device drivers. Only one compression algorithm 
can be used in any given direction but a different compression algorithms can be used for sending and 
receiving.

RouterWare CCP consists of a state machine module and a timer module for handling the option 
negotiations, a configuration module for processing the CCP configuration section, and four compression 
modules for packet compression/decompression. The timer module is currently triggered by the PPP layer.

Compressor and de-compressor synchronization mechanisms vary amongst the compression algorithms. 
When the sender and receiver become out of sync, the Predictor Type I Protocol receiver will send a new 
configuration request packet to force the sender out of the PPP_OPENED_STATE, which in turn will 
cause both sides to re-negotiate and reset their compression databases. For the other three compression 
algorithms, the receiver will send out a RESET_REQUEST packet to cause the sender to reset the 
compression database. Upon reception of a RESET_ACK, the receiver will clear its own compression 
database.

The Predictor Type II protocol is designed for used on a reliable link. LAPB is essential for correct 
delivery.

With the predictor compression algorithm as an exception, all algorithm implemented provide a way to 
turn the algorithm for speed/compression ratio trade-off. Please refer to the CCP Configuration section for 
the detail of these parameters.



 Header Files

vnvccp.h
CCP table driven configuration header file

vccpstr.h
CCP structures/unions declarations and function prototypes

ccp.h
CCP meta-include file

vccpstat.h
CCP state machine definition

kccp.h
CCP #defines, enums, and version information

vccp.h
CCP class definition

bsdcomp.h
header file for the BSD LZW compression algorithm implementation

predict.h
header file for the Predictor compression algorithm implementation

lzsc
header file for the Stacker LZS compression algorithm implementation This file is the 
property of Stac Electronics.  RouterWare only made cross-platform compilation 
modifications to it.


ccp.h organization
RouterWare's CCP is a subsystem of the RouterWare PPP implementation and thus its source files are organized in a sub-
directory located under the PPP branch of the RouterWare code tree. RouterWare's CCP needs to re-use many PPP declarations 
and thus CCP's ccp.h is somewhat different from other RouterWare stacks because it needs to include PPP header files.  For 
reference, the following is the section of code in ccp.h that includes PPP header files.

#include <kppp.h>
#include <vlcpstr.h>
#include <vnipstr.h>
#include <vnipxstr.h>
#include <vnatstr.h>
#include <vnnbsstr.h>
#include <vnstpstr.h>
#include <vncpstr.h>
#include <vpppastr.h>

#if defined (GLOBAL_FILE)
	#undef GLOBAL_FILE
	#include <vpppstr.h>
	#define GLOBAL_FILE
#else
	#include <vpppstr.h>
#endif

The C conditional compilation macro is used to prevent the CRC checksum table (which is defined in PPP) from being included 
twice.



Source Files

ccpinit.c
CCP initialization functions

ccpdebug.c
CCP DLL debugging tools

ccpconfg.c
CCP configuration functions

ccptx.c
CCP option negotiation packets transmission functions

ccpupcal.c
CCP event up-call functions

ccputil.c
CCP utility functions

ccprx.c
CCP option negotiation packets receive functions

ccpstate.c
CCP state-machine execution functions

bsdcomp.c
BSD LZW compression algorithm implementation

ccppred1.c
CCP Predictor type I Protocol implementation

ccppred2.C
CCP Predictor type II Protocol implementation

lzsc.c
Stacker LZS compression algorithm implementation.  This file is the property of Stac 
Electronics.  RouterWare only made cross-platform compilation modifications to it.

ccpbsd.c
CCP BSD Compression Protocol implementation

ccpstac.c
CCP Stacker LZS Compression Protocol implementation

predict.c
Predictor compression algorithm implementation

ccpoptnp.c
CCP option negotiation processing functions

ccptimer
CCP timer function




Constants and Enums of Note

CCP
must be defined 

LSL
should be defined when using RouterWare's LSL

__BIG_ENUMS__
must be defined

NUMBER_OF_IP_PORTS=16
must be defined

LSL_HEADER_TRANSLATION
must be defined

__FLAT__
must be defined

CCP_MODULE
must be defined in ccpinit.c before #include "ccp.h" for the DLL 
version






CCP Intialization

The CCP module is initialized by PPP via the function initialize_ccp().  The function prototype for 
initialize_ccp() appears in the vpppstr.h file of RouterWare's PPP module since the prototype is needed by 
both PPP and CCP. The C marco #define CCP_MODULE should be the first C code in CCP's ppp.h file, 
which appends _EXTERN to CCP's version of the prototype for DLL linkage.
initialize_ccp() function prototype

#if defined (CCP)
	
	/* ccp\ccpinit.c */
	
	#if defined (CCP_MODULE)
		_EXTERN 
	#endif

	void initialize_ccp 
	(
		USHORT number_of_ppp_ports, 
		
		void (**ptr_fptr_execute_ccp_state_machine_function) (enum PPP_EVENT ppp_event, 
USHORT real_port_number, void *vptr_packet, USHORT number_of_bytes),

PPP_PACKET_WITH_MAC_HEADER	*(*(**ptr_fptr_get_sender_compression_function_function) 
(USHORT real_port_number)) (USHORT real_port_number, USHORT 
protocol_virtual_port_number, enum BOOLEAN device_driver_buffer, 
			PPP_PACKET_WITH_MAC_HEADER *sptr_ppp_packet, USHORT *usptr_ppp_packet_length,
			void (**fptr_tx_completion) (USHORT port_number, void *vptr_buffer)),

UNION_PPP_PACKET *(*(**ptr_fptr_get_receiver_decompression_function_function) (USHORT 
real_port_number)) (USHORT real_port_number, UNION_PPP_PACKET *uptr_ppp_packet, 
USHORT *usptr_ppp_packet_length),

		void (**ptr_fptr_ccp_timer_routine) (USHORT real_port_number, 
USHORT number_of_protocol_stacks_loaded, 
ULONG maximum_configuration_request_send_interval, 
ULONG maximum_number_of_configuration_requests, 
			ULONG maximum_termination_request_send_interval, 
ULONG maximum_number_of_termination_requests),

enum TEST (**ptr_fptr_ccp_packet_received_function) (USHORT real_port_number, void 
*vptr_ccp_rx_packet, USHORT number_of_bytes_rxed),
		
		OPTION_LISTS (**ptr_fptr_get_ccp_option_lists_function) (USHORT real_port_number),

		enum PPP_STATE (**ptr_fptr_get_ccp_state_function) (USHORT real_port_number), 

		enum BOOLEAN (**ptr_fptr_get_sender_compression_database_initialization_status_function) 
(USHORT real_port_number),

		enum BOOLEAN (**ptr_fptr_get_receiver_compression_database_initialization_status_function) 
(USHORT real_port_number),

		enum BOOLEAN (**ptr_fptr_get_ccp_port_status_function) (USHORT real_port_number),
		
		BYTE (**ptr_fptr_get_last_id_of_ccp_packet_sent_function) (USHORT real_port_number),

		ULONG (*fptr_get_device_driver_id_function) (USHORT real_port_number),
		ULONG (*fptr_get_maximum_number_of_termination_requests_function) (void),
		ULONG (*fptr_get_ppp_remote_MRU_function) (USHORT real_port_number),
		OPTION_LISTS *(*fptr_get_ccp_option_lists_created_by_ppp_function) (USHORT real_port_number)
	);
#endif



initialize_ccp() function parameters

CCP is initialized via the following call, found in RouterWare's PPP v1.60. initialize_ccp () directly registers CCP's functions 
into PPP.


#if defined (CCP)
	if (ppp.ccp.enabled == TRUE)
		{
		initialize_ccp (ppp.number_of_ppp_ports, 
			&ppp.ccp.fptr_execute_ccp_state_machine_function,	
			&ppp.ccp.fptr_get_sender_compression_function_function, 
			&ppp.ccp.fptr_get_receiver_decompression_function_function,
			&ppp.ccp.fptr_ccp_timer_routine, 
			&ppp.ccp.fptr_ccp_packet_received_function, 
			&ppp.ccp.fptr_get_ccp_option_lists_function,
			&ppp.ccp.fptr_get_ccp_state_function, 
			&ppp.ccp.fptr_get_sender_compression_database_initialization_status_function,
			&ppp.ccp.fptr_get_receiver_compression_database_initialization_status_function,
			&ppp.ccp.fptr_get_ccp_port_status_function,
			&ppp.ccp.fptr_get_last_id_of_ccp_packet_sent_function, 
			
			get_device_driver_id, 
			get_maximum_number_of_termination_requests,
			get_ppp_remote_MRU, 
			get_ccp_option_lists_created_by_ppp);
		}
#endif





The initialize_ccp() function causes PPP and CCP to trade function pointers to the following functions. 
initialize_ccp() is called from within initialize_ppp().
CCP Functions Registering into PPP

Registered Function Name
Description of CCP Function

execute_ccp_state_machine () 
 this function is needed by PPP to "up" the 
CCP state machine once the LCP option 
negotiation is finished.

get_ccp_port_status ()
Needed by PPP to check if a particular PPP 
port is enabled or disabled.

get_sender_compression_function () 
Needed by PPP to have access to the CCP 
negotiated primary compression function. 
This function returns a pointer to the 
compression function.

get_receiver_decompressioin_function () 
Needed by PPP to have access to the CCP 
negotiated primary decompression function. 
This function returns a pointer to the 
decompression function.

ccp_timer_routine () 
Handle used PPP to trigger the CCP timer.

get_ccp_option_lists () 
Needed by PPP to access the CCP option 
lists.

get_ccp_state () 
Needed by PPP to obtain the state of the 
CCP state machine.

get_sender_compression_database_initialization_status () 
Needed by PPP to know if the compression 
libraries have been initialized properly by 
CCP.

get_receiver_compression_database_initialization_status () 
Needed by PPP to know if the 
decompression libraries have been 
initialized properly by CCP.

get_last_id_of_ccp_packet_sent () 
The last sent CCP packet ID is needed by 
PPP.


PPP Functions Registering into CCP

Registered Function Name
Description of  PPP Function

get_device_driver_id () 
CCP needs PPP device driver IDs to 
allocate/de-allocate device driver buffers.

get_maximum_number_of_termination_requests () 
Needed by CCP to handle option 
negotiation.

get_ppp_remote_MRU () 
Needed by CCP to know the LCP 
negotiated remote MRU.

get_ccp_option_lists_created_by_ppp () 
PPP is responsible for creating part of the 
CCP option lists and therefore CCP needs 
to be able to have access to this partial lists.




API Functions Organization

Each compression protocol needs four different functions to operate: compression, decompression, RESET 
REQUEST handling, and RESET ACK handling.  These functions are organized in a class called 
CCP_FUNCTIONS.  An array of CCP_FUNCTIONS CLASS indexed by the negotiated CCP options is 
used so that each function may be easily referenced.



 Compressor API

The API for the compressor is the same as the PPP transmission API :

PPP_PACKET_WITH_MAC_HEADER *(*COMPRESSOR_NAME) (USHORT 
real_port_number,USHORT rotocol_virtual_port_number, enum BOOLEAN 
device_driver_buffer, PPP_PACKET_WITH_MAC_HEADER *sptr_ppp_packet, USHORT 
*usptr_ppp_packet_length, void (**fptr_tx_completion) (USHORT port_number,void 
*vptr_buffer));

The RouterWare naming convention for CCP compressors is [Protocol Name]_compress_ppp.  Four 
compressors are implemented: predictor_type_I_compress_ppp, predictor_type_II_compress_ppp, 
BSD_compress_ppp, and stacker_compress_ppp.



Decompressor API

UNION_PPP_PACKET *(*DECOMPRESSOR_NAME) (USHORT real_port_number, 
UNION_PPP_PACKET *uptr_ppp_packet, USHORT *usptr_ppp_packet_length);

The RouterWare naming convention for CCP decompressors is [Protocol Name]_decompress_ppp.  Four 
decompressors are implemented: predictor_type_I_decompress_ppp, predictor_type_II_decompress_ppp, 
BSD_decompress_ppp, and stacker_decompress_ppp.



RESET REQUEST API

Each compression protocol need to handle RESET REQUEST differently. RouterWare provides the same 
API for all of them:

void (*NAME_OF_RESET_REQUEST_HANDLER) (USHORT real_port_number, 
CCP_PACKET *sptr_ccp_rx_packet);

The RouterWare naming convention for RESET REQUEST handler is 
[Protocol Name]_handle_reset_request.  Three handlers are implemented: 
predictor_handle_reset_request, BSD_handle_reset_request, and stacker_handle_reset_request.
Predictor Type I and Predictor Type II handle RESET REQUEST the same way.



RESET ACK API

Each compression protocol need to handle RESET ACK differently. RouterWare provides the same API 
for all of them:

void (*NAME_OF_RESET_ACK_HANDLER (USHORT real_port_number, 
CCP_PACKET *sptr_ccp_rx_packet);

The RouterWare naming convention for RESET ACK handler is 
[Protocol Name]_handle_reset_ack.  Three handlers are implemented: predictor_handle_reset_ack, 
BSD_handle_reset_ack, and stacker_handle_reset_ack.
Predictor Type I and Predictor Type II handle RESET REQUEST the same way.



PPP .INI Configuration Parameters
[[ PPP Compression = Section Start ]]
PPP CCP = [enabled|disabled]
Enable/disable CCP operation.



CCP .INI Configuration Parameters
Most parameters utilized by CCP are derived from negotiation with the CCP peer.  CCP may use 
different compression algorithms for each direction of the link as well as per each WAN port.

 [[ CCP Compression = Section Start ]]
CCP configuration section header string.  This string must precede all of the CCP configuration 
parameters defined below.
CCP Port = [WW], [enabled|disabled]
Enable/disable CCP operation on the specified WAN port.
CCP Port Stacker Performance Value = [WW], [decimal value 0-255]
Defines the Stacker Performance Value to be utilized.  These modes are unnamed and are 
referred to by a mode number ranging from 0 to 255.  In general, the higher the number, the higher the 
compression ratio (and correspondingly slower in compression speed.)
CCP Port Stacker Performance Mode =  [WW], [decimal value 0-2]
Defines the Stacker Performance Mode to be utilized.  These modes are unnamed and are 
referred to by a mode number ranging from 0 to 2.  In general, the higher the number, the higher the 
compression ratio (and correspondingly slower in compression speed.)
CCP Port Option = [WW], CCP, [comma separated parameters]
CCP will construct an option list for its configuration request messages based upon the presence 
of CCP Port Option statements.  CCP peers will negotiate to use the first compression algorithm in the 
option list that both CCP peers support.  The option list is constructed directly from the CCP Port Option 
statements, the ordering of these statements will control the ordering within the option list.  As a result, 
one can control the preference for a particular compression algorithm by placing it closer to the start of 
the list.  This is achieved by ordering the CCP Port Option statements from most desirable in the first 
position and least desirable in the last position.

The following table illustrates the parameters that are to be separated by commas following the 
"CCP" keyword in the CCP Port Option statement.  Refer to Stacker LZS [1] and BSD LZW [2] 
documentation for definition of option values. 

Predictor Type I
1
Auto
Negotiation 
Not Required
[Not] 
Negotiable
H0


Predictor Type II
2
Auto
Negotiation 
Not Required
[Not] 
Negotiable
H0


Stacker LZS 
Compression
17
Auto
Negotiation 
Not Required
[Not]
Negotiable
H3
000102

BSD LZW 
Compress
21
Auto
Negotiation 
Not Required
[Not] 
Negotiable
H1
2C


CCP Port Remote Option = [WW], CCP, [comma separated parameters]
CCP will receive configuration requests that, presumably, will contain one or more compression 
algorithms and perhaps configuration algorithm parameters within the option list.  CCP will compare the 
proposed options, one at a time, against the list specified by the CCP Port Remote Option statements until 
it either finds a matching entry or exhausts all choices. 

In the case of Predictor Type I and II protocols, there is no value to be negotiated and thus the 
Negotiable and H0 keywords are simply placeholders.  For the Stacker LZS algorithm, multiple 
configurations may be simultaneously proposed, the supported values being described elsewhere.  The 
same applies to the BSD LZW algorithm. 

As with the CCP Port Option, a preference can be established by ordering the list of statements.

If a compression protocol is supported, the following table shows the REQUIRED statement(s) to 
be used.  The  "alternate" keyword is used to specify a list of values to be considered when evaluating a 
received option request.  Stacker LZS must not be allowed to negotiate a value outside of the values shown 
below and thus the Not Negotiable keyword is specified in the first instance of a Stacker LZS Compression 
statement.

BSD LZW supports several different option values, all of which fall within a contiguous set of 
numbers.  In this case, the "range" keyword is used.  The "range" keyword takes, as arguments, the 
starting, ending, and increment values.  The "alternate" keyword would have sufficed as well except this 
form of coding is more compact.  As with Stacker LZW Compression, values outside of this set are not to 
be negotiated and thus the Not Negotiable keyword is specified.

Note:  When making use of the "alternate" and "range" keywords, the RouterWare configuration 
process requires that an initial "auto" statement be used that specifies the first item in the list of values to 
be supported.

Predictor Type I
1
Auto
Negotiation 
Not 
Required
Negotiable
H0


Predictor Type II
2
Auto
Negotiation 
Not 
Required
Negotiable
H0


Stacker LZS 
Compression
17
Auto
Negotiation 
Not 
Required
Not 
Negotiable
H3
000000

Stacker LZS 
Compression
17
Alternate
H3
000001



Stacker LZS 
Compression
17
Alternate
H3
000002



Stacker LZS 
Compression
17
Alternate
H3
000003



Stacker LZS 
Compression
17
Alternate
H3
000100



Stacker LZS 
Compression
17
Alternate
H3
000101



Stacker LZS 
Compression
17
Alternate
H3
000102



Stacker LZS 
Compression
17
Alternate
H3
000103



BSD LZW 
Compress
21
Auto
Negotiation 
Not 
Required
Not 
Negotiable
H1
29

BSD LZW 
Compress
21
Range
H1
29
2F
01


CCP Initialization Breakpoint =  [enabled|disabled]
Used for DLL debugging.  Set to disabled.
CCP Run Time Breakpoint =  [enabled|disabled]
Used for DLL debugging.  Set to disabled.

CCP Printf Control
CCP Printf = [enabled|disabled]
CCP Printf Data = [enabled|disabled]
CCP Printf Memory = [enabled|disabled]
CCP Printf Alarm = [enabled|disabled]



Predictor Type I Option Notes

No values are negotiated, just absence or presence of this algorithm.

Predictor Type II Option Notes

Intended for use with a reliable serial link, in particular one utilizing LAPB, because the 
compression dictionary is recovered from the compressed data stream, and a lost datagram 
corrupts the dictionary, thus datagrams must not be lost.  No values are negotiated, just absence 
or presence of this algorithm.  Refer to RFC 1663  and ISO 7776  for further details.


Stacker LZS Option Notes

The most significant two bytes (e.g. 0x0001 in example above) is the number of compression 
histories to be used by Stacker.  RouterWare supports either 0x0000 or 0x0001.  When no history 
is used, the algorithm does not rely upon a reliable link and does not require that packets be 
delivered in sequence.

The least significant byte (e.g. 02 in example above) specifies the Check Mode used by Stacker 
LZS.  RouterWare supports all four modes defined:
0x00:	No Check
0x01:	Use Longitudinal Check Byte method
0x02:	16 bit CRC
0x03:	Sequence Number

BSD LZW Option Notes

This one byte value is defines the "Longest Code Word" of which RouterWare supports values 
ranging from 0x29 to 0x2F.  The smaller the value, the lower the compression ratio (and thus the 
lower computational requirements).  The recommended value is 0x2C.


Notes Concerning Stac Electronics LZS

RouterWare's Stacker Compression Protocol implementation is based on Stac Electronics' compression 
algorithm implementation LZS221-C Version 3.01. RouterWare made three modifications to the Stac C 
code for cross-platform compilation.

Lzsc.h (line 79)

Stac Code 		#define	LZS_TARGET			LZS_INTEL_86	/* selected from the list above */
RouterWare Modification	#define	LZS_TARGET			LZS_ANSI	/* selected from the list above */

lzsc.c  (line 185)

Stac Code		typedef	unsigned	int		uint;		/* 16 bits */
RouterWare Modification	typedef	unsigned	short		uint;		/* 16 bits */

lzsc.c (line 190)

Stac Code		typedef	signed		int		sint;		/* 16 bits */
RouterWare Modification	typedef	signed		short		sint;		/* 16 bits */




References
  Rand, D., Editor, "PPP Compression Control Protocol (CCP)", draft-ietf-pppext-compression-04.txt, 
Novell, March 1994.
  Rand, D., Editor, "PPP Predictor Compression Protocol ", draft-ietf-pppext-predictor-00.txt, Novell, 
December 1993.
  Lutz & Simpson, Editors, "PPP Stacker LZS Compression Protocol", draft-ietf-pppext-stacker-03.txt, 
Stac Electronics & Daydreamer, March 1995.
  Schryver, Editor,  "PPP BSD Compression Protocol", draft-ietf-pppext-bsd-compress-04.txt, May 1995.
  Rand, D., Editor, "PPP Reliable Transmission", RFC1663, Novell, July 1994.
  ISO 7776, Information Processing Systems - Data Communication - High Level Data Link Control 
Procedures - Description of the X.25 LAPB-Compatible DTE Data Link Procedures








	

23





