Software Defined Networking Architecture, Security and Energy Efficiency: A Survey <s> A. The SDN Architecture <s> As anyone who has operated a large network can attest, enterprise networks are difficult to manage. That they have remained so despite significant commercial and academic efforts suggests the need for a different network management paradigm. Here we turn to operating systems as an instructive example in taming management complexity. In the early days of computing, programs were written in machine languages that had no common abstractions for the underlying physical resources. This made programs hard to write, port, reason about, and debug. Modern operating systems facilitate program development by providing controlled access to high-level abstractions for resources (e.g., memory, storage, communication) and information (e.g., files, directories). These abstractions enable programs to carry out complicated tasks safely and efficiently on a wide variety of computing hardware. In contrast, networks are managed through low-level configuration of individual components. Moreover, these configurations often depend on the underlying network; for example, blocking a user’s access with an ACL entry requires knowing the user’s current IP address. More complicated tasks require more extensive network knowledge; forcing guest users’ port 80 traffic to traverse an HTTP proxy requires knowing the current network topology and the location of each guest. In this way, an enterprise network resembles a computer without an operating system, with network-dependent component configuration playing the role of hardware-dependent machine-language programming. What we clearly need is an “operating system” for networks, one that provides a uniform and centralized programmatic interface to the entire network. Analogous to the read and write access to various resources provided by computer operating systems, a network operating system provides the ability to observe and control a network. A network operating system does not manage the network itself; it merely provides a programmatic interface. Applications implemented on top of the network operating system perform the actual management tasks. The programmatic interface should be general enough to support a broad spectrum of network management applications. Such a network operating system represents two major conceptual departures from the status quo. First, the network operating system presents programs with a centralized programming model; programs are written as if the entire network were present on a single machine (i.e., one would use Dijkstra to compute shortest paths, not Bellman-Ford). This requires (as in [3, 8, 14] and elsewhere) centralizing network state. Second, programs are written in terms of high-level abstractions (e.g., user and host names), not low-level configuration parameters (e.g., IP and MAC addresses). This allows management directives to be enforced independent of the underlying network topology, but it requires that the network operating system carefully maintain the bindings (i.e., mappings) between these abstractions and the low-level configurations. Thus, a network operating system allows management applications to be written as centralized programs over highlevel names as opposed to the distributed algorithms over low-level addresses we are forced to use today. While clearly a desirable goal, achieving this transformation from distributed algorithms to centralized programming presents significant technical challenges, and the question we pose here is: Can one build a network operating system at significant scale? <s> BIB001 </s> Software Defined Networking Architecture, Security and Energy Efficiency: A Survey <s> A. The SDN Architecture <s> We describe a language-centric approach to solving the complex, low-level, and error-prone problem of network control. Specifically, we have designed a domain-specific language called Nettle, embedded in Haskell, that allows programming OpenFlow networks in an elegant, declarative style. Nettle is based on the principles of functional reactive programming (FRP), and as such has both continuous and discrete abstractions, each of which is leveraged in the design. We have implemented Nettle and tested it on real OpenFlow switches. We demonstrate our methodology by writing several non-trivial OpenFlow controllers. <s> BIB002 </s> Software Defined Networking Architecture, Security and Energy Efficiency: A Survey <s> A. The SDN Architecture <s> SDN separates the control plane and data plane. SDN needs to be equipped with complex and proprietary networking devices as it needs to separate the infrastructure layer (network device) from the control layer (network OS, which provides a central view and control over the network and network services) and the application layer (software/business application)[1][6][8]. When a single controller is given the job of controlling multiple devices (switches/routers) these changes in network structure brought about by SDN will inevitably impact on network security. In this paper we studied issues and security challenges in SDN and current status. <s> BIB003 </s> Software Defined Networking Architecture, Security and Energy Efficiency: A Survey <s> A. The SDN Architecture <s> Software-defined network (SDN) has become one of the most important architectures for the management of largescale complex networks, which may require repolicing or reconfigurations from time to time. SDN achieves easy repolicing by decoupling the control plane from data plane. Thus, the network routers/switches just simply forward packets by following the flow table rules set by the control plane. Currently, OpenFlow is the most popular SDN protocol/standard and has a set of design specifications. Although SDN/OpenFlow is a relatively new area, it has attracted much attention from both academia and industry. In this paper, we will conduct a comprehensive survey of the important topics in SDN/OpenFlow implementation, including the basic concept, applications, language abstraction, controller, virtualization, quality of service, security, and its integration with wireless and optical networks. We will compare the pros and cons of different schemes and discuss the future research trends in this exciting area. This survey can help both industry and academia R&D people to understand the latest progress of SDN/OpenFlow designs. <s> BIB004
SDN is regarded as an emerging technology where the primary concept is removing the intelligence from the networking devices and managing the entire network functionality with the help of a centralized controller. The basic structure of SDN is represented in Fig. 2 . It consists of three different layers: Application layer, Control layer and Infrastructure layer. 1) Infrastructure/Data Layer: Infrastructure layer (aka data layer) in SDN comprises of network devices such as router, switch and access point. Both virtual switches such as Open vSwitch, Indigo, Pica8, Nettle, Open Flowj and physical switches coexist in this layer BIB004 ,  ,  - BIB002 . The main function of the data plane is forwarding the packets according to the assigned rules/policies. 2) Control Layer: Control layer consists of a controller which controls the overall SDN functions. This layer acts as a mediator for infrastructure layer and application layer. The controller is responsible for managing the entire traffic flow and solely takes decisions on routing, flow forwarding and packet dropping through programming [9], BIB003 , BIB001 . The controllers in the distributed environment communicate with each other through east-bound and west-bound interfaces. The control layer and the infrastructure layer communicate with each other through south-bound API such as OpenFlow, NetConf, etc.  . 3) Application Layer: The Application layer is the foremost layer in the SDN as shown in Fig. 2 . It is responsible for handling software related business and security applications. Network virtualization, Intrusion Detection Systems (IDS), Intrusion Prevention Systems (IPS), firewall implementation and mobility management are some examples of applications handled by this layer. This layer communicates with the control layer using Application Control Plane Interface (A-CPI) also called as northbound application interface  as shown in Fig. 2 .