Socket API Research Articles

A Design of an SMTP Email Server

This study developed a mail server program using Socket API and Python. The program uses the Hypertext Transfer Protocol (HTTP) to receive emails from browser clients and forward them to actual email service providers via the Simple Mail Transfer Protocol (SMTP). As a web server, it handles Transmission Control Protocol (TCP) connection requests from browsers, receives HTTP commands and email data, and temporarily stores the emails in a file. Simultaneously, as an SMTP client, the program establishes a TCP connection with the actual mail server, sends SMTP commands, and transmits the previously saved emails. In addition, we also analyzed security issues and the efficiency and availability of this server, providing insights into the design of SMTP mail servers.

Improving the efficiency of SCTP network software

The work presents a software system for demonstrating the operation of the SCTP transport protocol in comparison with its better-known analogues – TCP and UDP. To reproduce the operation of the chosen protocol, a socket API was created that describes the operation of SCTP, based on RFC 6458. It also describes the transport protocols that are similar to the protocol that was chosen to improve performance, namely TCP and UDP, their strengths and weaknesses, and what has been improved in SCTP. A test software model is described, which is divided into a client part and a server part, which was created to demonstrate the operation of the SCTP transport protocol. The client part consists in sending a message to the server, which will read this message and reset it. The ability to send using the SCTP protocol directly, or UDP encapsulation, thus encapsulating the SCTP packet into a UDP datagram, has been developed. The efficiency and expediency of using the software model are shown and alternative software models designed to implement the SCTP protocol are considered. The means used to implement this decision are justified as well as the platforms and operating systems on which this solution can be reproduced, other than Windows.

End-To-End Mobility for the Internet Using ILNP

As the use of mobile devices and methods of wireless connectivity continue to increase, seamless mobility becomes more desirable and important. The current IETF Mobile IP standard relies on additional network entities for mobility management, can have poor performance, and has seen little deployment in real networks. We present a host-based mobility solution with a true end-to-end architecture using the Identifier-Locator Network Protocol (ILNP). We show how the TCP code in the Linux kernel can be extended allowing legacy TCP applications that use the standard C sockets API to operate over ILNP without requiring changes or recompilation. Our direct testbed performance comparison shows that ILNP provides better host mobility support than Mobile IPv6 in terms of session continuity, packet loss, and handoff delay for TCP.

Compatibility enhancement and performance measurement for socket interface with PCIe interconnections

Today the key technology of high-performance computing systems is the emergence of interconnect technology that makes multiple computers into one computer cluster. This technique is a general method in which each constituent node processes its own operation and communicates with different nodes. Therefore, a high-performance network has been required. InfiniBand and Gigabit Ethernet technologies are typical examples of high-performance network. As an alternative to those technologies the development of interconnection technology using PCI Express (Peripheral Component Interconnect Express), officially abbreviated as PCIe or PCI-e, is a high-speed serial computer expansion bus standard, which has characteristics of high speed, low power, and high protocol efficiency is actively under development. In a high-performance network, the TCP/IP protocol consumes CPU resources and memory bandwidth by nature, which is a bottleneck. In this paper, we implement the PCIe based interconnection network system with low latency, low power, RDMA, and other characteristics. We utilize Socket API which is mainly used in the user-level application program rather than the existing MPI and PGAS model interfaces. The implemented PCIe interconnection network system was measured with the metrics as the bandwidth using the Iperf Benchmark which uses the Socket API. The bandwidth at 4 Mbyte of transmission data size was measured to be 1084 Mbyte/s bandwidth based on PCIe, which is about 96 times higher than that of 11.2 Mbyte/s bandwidth based on Ethernet.

Engineering with Logic

Conventional computer engineering relies on test-and-debug development processes, with the behavior of common interfaces described (at best) with prose specification documents. But prose specifications cannot be used in test-and-debug development in any automated way, and prose is a poor medium for expressing complex (and loose) specifications. The TCP/IP protocols and Sockets API are a good example of this: they play a vital role in modern communication and computation, and interoperability between implementations is essential. But what exactly they are is surprisingly obscure: their original development focused on “rough consensus and running code,” augmented by prose RFC specifications that do not precisely define what it means for an implementation to be correct. Ultimately, the actual standard is the de facto one of the common implementations, including, for example, the 15 000 to 20 000 lines of the BSD implementation—optimized and multithreaded C code, time dependent, with asynchronous event handlers, intertwined with the operating system, and security critical. This article reports on work done in the Netsem project to develop lightweight mathematically rigorous techniques that can be applied to such systems: to specify their behavior precisely (but loosely enough to permit the required implementation variation) and to test whether these specifications and the implementations correspond with specifications that are executable as test oracles . We developed post hoc specifications of TCP, UDP, and the Sockets API, both of the service that they provide to applications (in terms of TCP bidirectional stream connections) and of the internal operation of the protocol (in terms of TCP segments and UDP datagrams), together with a testable abstraction function relating the two. These specifications are rigorous, detailed, readable, with broad coverage, and rather accurate. Working within a general-purpose proof assistant (HOL4), we developed language idioms (within higher-order logic) in which to write the specifications: operational semantics with nondeterminism, time, system calls, monadic relational programming, and so forth. We followed an experimental semantics approach, validating the specifications against several thousand traces captured from three implementations (FreeBSD, Linux, and WinXP). Many differences between these were identified, as were a number of bugs. Validation was done using a special-purpose symbolic model checker programmed above HOL4. Having demonstrated that our logic-based engineering techniques suffice for handling real-world protocols, we argue that similar techniques could be applied to future critical software infrastructure at design time, leading to cleaner designs and (via specification-based testing) more robust and predictable implementations. In cases where specification looseness can be controlled, this should be possible with lightweight techniques, without the need for a general-purpose proof assistant, at relatively little cost.

Implementasi Sistem Interkoneksi Basis Data Terdistribusi Menggunakan Socket API


 Majelis Pendidikan Dasar dan Menengah Pimpinan Daerah Kabupaten Magelang needs information about the development of the school. The necessary data include data on human resources, asset data and data of their students. At the moment the data is obtained manually by looking to the schools. With the development of information technology is now expected to have a school information system that can provide information quickly and accurately. Data on each school if put into one large server or big data can be used to analyze the data. The purpose of this research is to implement the interconnection of distributed database system using the socket API. It is used to provide master data of all schools under Persyarikatan Muhammadiyah. To support the analysis of the data interconnection of distributed databases, socket API technology is used. With a system like this then the communications database can be connected so that the school's data will be sent directly through the socket API and the data will automatically be processed by the webservice in the server middleware and will be utilized in the next process.

Cedos: A Network Architecture and Programming Abstraction for Delay-Tolerant Mobile Apps

Delay-tolerant Wi-Fi offloading is known to improve overall mobile network bandwidth at low delay and low cost. Yet, in reality, we rarely find mobile apps that fully support opportunistic Wi-Fi access. This is mainly because it is still challenging to develop delay-tolerant mobile apps due to the complexity of handling network disruptions and delays. In this paper, we present Cedos, a practical delay-tolerant mobile network access architecture in which one can easily build a mobile app. Cedos consists of three components. First, it provides a familiar socket API whose semantics conforms to TCP, while the underlying protocol, $\text{D}^{2}$ TP, transparently handles network disruptions and delays in mobility. Second, Cedos allows the developers to explicitly exploit delays in mobile apps. App developers can express maximum user-specified delays in content download or use the API for real-time buffer management at opportunistic Wi-Fi usage. Third, for backward compatibility to existing TCP-based servers, Cedos provides $\text{D}^{2}$ Prox, a protocol-translation Web proxy. $\text{D}^{2}$ Prox allows intermittent connections on the mobile device side, but correctly translates Web transactions with traditional TCP servers. We demonstrate the practicality of Cedos by porting mobile Firefox and VLC video streaming client to using the API. We also implement delay/disruption-tolerant podcast client and run a field study with 50 people for eight weeks. We find that up to 92.4% of the podcast traffic is offloaded to Wi-Fi, and one can watch a streaming video in a moving train while offloading 48% of the content to Wi-Fi without a single pause.

NEAT: A Platform- and Protocol-Independent Internet Transport API

The sockets API has become the standard way that applications access the transport services offered by the IP stack. This article presents NEAT, a user space library that can provide an alternate transport API. NEAT allows applications to request the service they need using a new design that is agnostic to the specific choice of transport protocol underneath. This not only allows applications to take advantage of common protocol machinery, but also eases introduction of new network mechanisms and transport protocols. The article describes the components of the NEAT library and illustrates the important benefits that can be gained from this new approach. NEAT is a software platform for developing advanced network applications that was designed in accordance with the standardization efforts on transport services in the IETF, but its features exceed the envisioned functionality of a TAPS system.

CliMB

Click has significant advantages for middlebox development, including modularity, extensibility, and reprogrammability. Despite these features, Click still has no native TCP support and only uses nonblocking I/O, preventing its applicability to middleboxes that require access to application data and blocking I/O. In this paper, we attempt to bridge this gap by introducing Click middleboxes (CliMB). CliMB provides a full-fledged modular TCP layer supporting TCP options, congestion control, both blocking and nonblocking I/O, as well as socket and zero-copy APIs to applications. As a result, any TCP network function may now be realized in Click using a modular L2-L7 design. As proof of concept, we develop a zero-copy SOCKS proxy using CliMB that shows up to 4x gains compared to an equivalent implementation using the Linux in-kernel network stack.

Scalable Kernel TCP Design and Implementation for Short-Lived Connections

With the rapid growth of network bandwidth, increases in CPU cores on a single machine, and application API models demanding more short-lived connections, a scalable TCP stack is performance-critical. Although many clean-state designs have been proposed, production environments still call for a bottom-up parallel TCP stack design that is backward-compatible with existing applications. We present Fastsocket, a BSD Socket-compatible and scalable kernel socket design, which achieves table-level connection partition in TCP stack and guarantees connection locality for both passive and active connections. Fastsocket architecture is a ground up partition design, from NIC interrupts all the way up to applications, which naturally eliminates various lock contentions in the entire stack. Moreover, Fastsocket maintains the full functionality of the kernel TCP stack and BSD-socket-compatible API, and thus applications need no modifications. Our evaluations show that Fastsocket achieves a speedup of 20.4x on a 24-core machine under a workload of short-lived connections, outperforming the state-of-the-art Linux kernel TCP implementations. When scaling up to 24 CPU cores, Fastsocket increases the throughput of Nginx and HAProxy by 267% and 621% respectively compared with the base Linux kernel. We also demonstrate that Fastsocket can achieve scalability and preserve BSD socket API at the same time. Fastsocket is already deployed in the production environment of Sina WeiBo, serving 50 million daily active users and billions of requests per day.

Scalable Kernel TCP Design and Implementation for Short-Lived Connections

With the rapid growth of network bandwidth, increases in CPU cores on a single machine, and application API models demanding more short-lived connections, a scalable TCP stack is performance-critical. Although many clean-state designs have been proposed, production environments still call for a bottom-up parallel TCP stack design that is backward-compatible with existing applications. We present Fastsocket, a BSD Socket-compatible and scalable kernel socket design, which achieves table-level connection partition in TCP stack and guarantees connection locality for both passive and active connections. Fastsocket architecture is a ground up partition design, from NIC interrupts all the way up to applications, which naturally eliminates various lock contentions in the entire stack. Moreover, Fastsocket maintains the full functionality of the kernel TCP stack and BSD-socket-compatible API, and thus applications need no modifications. Our evaluations show that Fastsocket achieves a speedup of 20.4x on a 24-core machine under a workload of short-lived connections, outperforming the state-of-the-art Linux kernel TCP implementations. When scaling up to 24 CPU cores, Fastsocket increases the throughput of Nginx and HAProxy by 267% and 621% respectively compared with the base Linux kernel. We also demonstrate that Fastsocket can achieve scalability and preserve BSD socket API at the same time. Fastsocket is already deployed in the production environment of Sina WeiBo, serving 50 million daily active users and billions of requests per day.

The Design and Development of Controller Software for Scan/DF Subsystem

In modern receiver control applications achieving real time response is most important. The paper is a part of software development for CSM controller system. In this paper a real time application, for controlling SCAN/DF receiver simulator will be implemented using POSIX socket APIs on VxWorks RTOS and process the data from the Scan/DF receiver subsystem. The processed data can be used to develop a database for electronic order of battle. This application will be able to interact with receiver using socket APIs, to exchange command and data packets. TCP/IP based socket APIs will be used to realize the application.

Data Transmission of Ground Penetrating Radar over Wireless Network

A wireless data transmission system used to realize data transmission of ground penetrating radar (GPR) is designed. It including data receiver and sender overcomes the disadvantages of traditional GPR cable transmission system. STM32F407 chip and ATK-RM04 are core components of data sender. PC with a wireless network card is data receiver. System is designed with reference to C/S network model. Data receiver and sender are respectively developed with VC++ socket and RAW API of Lwip TCP/IP protocol stack. CP protocol is chosen as network transport protocol. Practical applications show that system can stably transmit data within 0m-20m and maximum loss rate is 0.005%. It is reliable and convenient for GPR’s application.

REST 웹서비스 Open API를 사용한 분산처리 기법 연구

The majority of next generation information systems will be working on portable mobile devices such as smartphones. REST Open API web services have quickly become popular among mobile application development. The use of REST web services are not only growing in popularity but totally changing the way of mobile applications development. This is because REST web services could be used in application development as a form of building blocks, which is completely independent, compatible, to any platforms. With this strength, REST web services encourage third party application to build add-on functionality. This research proposes the use of REST web service to replace the use of socket APIs into major internet communication APIs. To this end, this paper also provide performance evaluation of the REST web services compared to the conventional socket APIs, focusing on scalability by analytical and experimental evaluations. Finally, we summarize the possibility whether REST Open API web services have enough performance as future major internet communication primitive APIs..

ETSI compliant GeoNetworking protocol layer implementation for IVC simulations

AbstractInter-Vehicle Communication (IVC) is an important component of the ITS architecture, that enables Vehicle-to-Vehicle (V2V) and Vehicle-to-Infrastructure (V2I) communications. GeoNet project brought the IVC one step further by enabling transparent IP connectivity between vehicles and the infrastructure. Specifications produced by the GeoNet project have been incorporated into several ETSI standards, which define the geonetworking protocol layer and the IPv6-over-geonetworking adaptation layer. In this paper, we propose an ETSI complaint geonetworking protocol layer on the well known NCTUns simulation framework. We discuss the architecture of our implementation as well as NCTUns specific issues encountered during the implementation. We believe that, with this contribution, the researchers are provided with a scalable and flexible framework with Berkeley socket API access to applications and SQL based performance logging for post simulation evaluations.

Remote Data Acquisition System Based on Embedded RT-Thread

Currently integrated network controller could implement data transmission through Internet. But commonly they have higher power consumption, fewer channels which could not be changed and less TCP/IP connection. A remote data acquisition technology based on embedded real-time operating system RT-Thread is presented in this paper. Server and client were constructed respectively according to TCP/IP protocol stack provided by operating system itself. Hardware circuit was centered with large capacity enhanced MCU named STM32F103ZET6. Ethernet interface chip DM9000AEP and network connection HR911105A were applied in our system. Socket API interface functions provided by RT-Thread were utilized in client and server software programs. Experimental results show that this system needs less hardware sources to implement more TCP/IP connections during remote data acquisition process.

Tales from the jungle

We rely on a computational infrastructure that is a densely interwined mass of software and hardware: programming languages, network protocols, operating systems, and processors. It has accumulated great complexity, from a combination of engineering design decisions, contingent historical choices, and sheer scale, yet it is defined at best by prose specifications, or, all too often, just by the common implementations. Can we do better? More specifically, can we apply rigorous methods to this mainstream infrastructure, taking the accumulated complexity seriously, and if we do, does it help? My colleagues and I have looked at these questions in several contexts: the TCP/IP network protocols with their Sockets API; programming language design, including the Java module system and the C11/C++11 concurrency model; the hardware concurrency behaviour of x86, IBM POWER, and ARM multiprocessors; and compilation of concurrent code. In this talk I will draw some lessons from what did and did not succeed, looking especially at the empirical nature of some of the work, at the social process of engagement with the various different communities, and at the mathematical and software tools we used. Domain-specific modelling languages (based on functional programming ideas) and proof assistants were invaluable for working with the large and loose specifications involved: idioms within HOL4 for TCP, our Ott tool for programming language specification, and Owens's Lem tool for portable semantic definitions, with HOL4, Isabelle, and Coq, for the relaxed-memory concurrency semantics work. Our experience with these suggests something of what is needed to make full-scale rigorous semantics a commonplace reality.

An implementation and performance evaluation of kernel‐level RTP supporting the BSD socket API

AbstractRTP (Real‐time Transport Protocol) has been designed for efficient transmission of real‐time multimedia data on the Internet by Internet Engineering Task Force (IETF). Different applications tend to implement separate RTPs as a library. In order to resolve this problem, embeddedRTP was proposed as an RTP‐based kernel‐level protocol. This paper proposes the ExtendedERTP protocol based on the embeddedRTP protocol. This new protocol deals with a couple of issues, such as packet processing overhead and buffer requirement, and combines its Application Programming Interface (API) with Berkeley Software Distribution (BSD) socket's which have been widely utilized in network applications. This paper demonstrates that this integration makes it possible to transmit real‐time multimedia data through the existing interface of BSD socket API with nominal extra overhead. This paper also shows that the time and memory requirement for packet processing can be reduced by about 15–20% and by 3.5%, respectively, compared with those of embeddedRTP. Copyright © 2010 John Wiley & Sons, Ltd.

Whither sockets?

High bandwidth, low latency, and multihoming challenge the sockets API.

Whither Sockets?

One of the most pervasive and longest-lasting interfaces in software is the sockets API. Developed by the Computer Systems Research Group at the University of California at Berkeley, the sockets API was first released as part of the 4.1c BSD operating system in 1982. While there are longer-lived APIs, it is quite impressive for an API to have remained in use and largely unchanged for 27 years. The only major update to the sockets API has been the extension of ancillary routines to accommodate the larger addresses used by IPv6.