MODULAR SOFTWARE ARCHITECTURE AND IMPLEMENTATION OF OSI UPPER LAYER PROTOCOLS

Abstract

The upper layer protocols of the Open System Interconnection (OSI) refer to the session, presentation, and application layers of the seven-layer OSI Reference Model. These protocols enable application processes running on different computers to exchange Information across a heterogeneous network. The primary purpose of this project is to design and develop a comprehensive architecture which facilitates the development and Implementation of these protocol layers, particularly the application layer. The study Investigates various software architectures and produces one which gives the best compromise between modularity and efficiency. The architecture achieves its modularity through logical layer entity construction based on the protocol layering standards and the rich facilities of the operating systems In general. Each layer entity is Implemented as a collection of modules with well-defined Interfaces and the entire set of upper layer protocols as a process supported by an underlying transport subsystem. It achieves efficient design via the adoption of a common buffer management across the layers and the minimum use of overhead:bound operating system services. Being modular and efficient, the architecture offers upper layer protocol entities the potential to be ported to other operating system platform, or enhanced to keep in line with changes In standards, as well as easily integrated with a wide variety of application processes such as file transfer applications and name service applications, for the purpose of effective information exchange with minimum overheads. The common buffer management scheme adopted stipulates the use of a buffer cut-through scheme. This technique primarily involves the use of three kinds of buffers and a combination of complex buffer address chaining to accomplish the task of passing the Protocol Data Units (PDU) carrying user data and the Protocol Control Information (PCI) from one layer to the next. This avoids the need to copy data repeatedly across the layers when data is transmitted and received, thus making the system efficient. Compared with other layers, the application layer has a relatively complex structure to accommodate its diversified services and protocols. The comphrensive architecture addresses this by including a detailed functional architecture and an object-oriented architecture for this layer. Both architectures permit the flexible configuration of a wide spectrum of specific communication services that meet the communication requirements of diversified application programs. Development of the application layer protocols and integration of the application layer with application programs are significantly facilitated by these architectures. The functional architecture focuses on modeling the structure of the application layer by means of collections of routines and data structures to model various elements of the layer including the Application Service Elements (ASEs), the Single Association Control Functions (SACFs), and the Single Association Objects (SAOs). The routines exhibit well-defined interfaces which permit modular integration of the elements In the application layer including the File Transfer, Access and Management (FTAM) element and the Association Control Service Element (ACSE). It also facilitates the integration of the application layer as a whole with application programs of various nature such as a file server. As most application programs are designed In the functional paradigm, this architecture is extremely useful. The object-oriented architecture, on the other hand, focuses on modeling the application layer structure by means of object-oriented features, including object class Inheritance, encapsulation, and polymorphism. It has the advantage of being highly modular, close to the standards, and permits natural correlation between the architecture and the standards itself. These can significantly simplify implementation effort and software maintenance, particularly those prompted by changes in the standards. The PDUs exchanged by application-layer entities are specified in Abstract Syntax Notation One (ASN.1). Due to its Inherent complexity, ASN.1 Is extremely tedious to implement for any application-layer entity development. Thus, a general-purpose ASN.1 compiler together with its realization strategy is developed which will automate a large part of the realization process. Application developers use the compiler to compile ASN.1 PDUs and generate language-bound structures for manipulations. The structures are subsequently converted into an interim linked list of structure known as Presentation Elements (PEs), before being passed to the presentation layer for encoding and transmission. In the process, application developers will find the language-bound structures easy to handle as they are close to the original ASN.1 structures. On the other hand, the interim structure, being a consistent hierarchical construct, permits an easy development of a general-purpose encoding/decoding algorithm in the presentation layer. An FT AM subsystem has been implemented based on the functional application-layer architecture. The subsystem provides comprehensive and reliable file transfer, access and management services across an OSI-based network. It caters for reliable file transfer services via a class-3 error detection and recovery protocol. The design addresses the issues of docket management for error recovery and the realization of Virtual Filestore (VFS), an important component of FTAM, in the Operating System/2 (OS/2) environment. The architecture uses the ASN.1 realization strategy developed in the project to implement the FTAM PDUs (F-PDUs) and file data: the ASN.1 complier is used to generate the language-bound data structures of F-PDUs and the file data to be transferred. Performance measurement and analysis conducted on the error recovery protocol shows a 7%-overhead which suggests a justified ground for the use of reliable file transfer service. A Directory system has been designed and developed based on the object-oriented application-layer architecture. The system is able to perform distributed name services which map network names Into addresses. The design manifests a progressive modeling approach which models the Directory successively from rudimentary objects to complex objects based upon the Abstract Service Definition Convention (ASDC) of the Directory standards. The approach effectively maps many of the objects in the ASDC standard of the Directory into the design, realizing much of the benefits of object-oriented design particularly the object encapsulation and polymorphism. A Directory Information Tree (DIT) which is used to store information related to the network has been implemented. The DIT Is Implemented on the OS/2's Database System which is a relational database with user-friendly SOL interfaces. The implementation effort involves mapping the hierarchical DIT structure into the flat tables of the relational database. The mapping strategy is able to minimize table join operations as well as reduce data redundancy. Both FTAM and the Directory are supported by an implementation of the presentation-layer and session-layer protocols. The presentation-layer implementation provides basic data encoding/decoding services to the application-layer entities. The session-layer implementation is focused on providing basic session management functions including connection establishment, termination and token control required by the FTAM and the Directory. In the implementation, all software modules, except the Directory, are written in the C language. The flexibility of the language has greatly facilitated the effective implementation of the architecture and its data structures. The Directory is implemented in C++. The modular yet flexible feature of the language has greatly enhanced the ability to logically construct the Directory. The entire protocol suite is Implemented on the OS/2 platform running on 25MHz Personal Computers (PCs). The aggregate source code amount to a total of approximately 76,415.lines excluding comments.