csc383 computer networks
Skip this Video
Download Presentation
CSC383 Computer Networks

Loading in 2 Seconds...

play fullscreen
1 / 38

CSC383 Computer Networks - PowerPoint PPT Presentation

  • Uploaded on

CSC383 Computer Networks. Dr. Allen M. Johnson, Jr. History…. 1 st networks designed to share large-scale computational power 1 st commercially available network system was IBM’s PROFS system. (mainframes) Late 1960s, ARPA started investigating data networking.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'CSC383 Computer Networks' - tehya

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
csc383 computer networks

CSC383 Computer Networks

Dr. Allen M. Johnson, Jr.

  • 1st networks designed to share large-scale computational power
  • 1st commercially available network system was IBM’s PROFS system. (mainframes)
  • Late 1960s, ARPA started investigating data networking.
    • Idea of networking computers of different architectures
    • Thought to be a crazy idea by many
… History…
  • In the late 1970s inexpensive minicomputers provided time-sharing facilities to people within a department.
  • Organizations installed Local Area Networks (LANs) to interconnect these machines together.
  • ARPA chose to investigate a revolutionary approach, known as packet switching.
  • They hired people to work on network research and contractors to turn the designs into a working system called the ARPANET.
  • This was so successful that ARPA continued funding research into a networking technology called internetworking.
  • By the 1970s, internetworking was the focus of ARPA research and the Internet had emerged.
  • ARPA continued funding research into the 1980s,
  • Internet became a commercial success in the 1990s.
growth of internet
Growth of Internet
  • The Internet has grown from an early research prototype into a global communications system that connects every country.
  • By 1999, the Internet was growing so fast that a new computer was added to the Internet every second.
protocols and layering
Protocols and Layering
  • Computer networks are complex systems including both hardware and software.
  • Designers divided the communication problem into subparts, called layers, with the interfaces between the layers defined by protocols.
tcp ip layered model
TCP/IP Layered Model
  • physical layer corresponds to basic network hardware.
  • Network interface layer specifies how data is divided into frames for transmission over a network.
  • Internet layer protocols specify the format of packets sent across an internet as well as the mechanisms used to forward packets from a computer through one or more routers to a final destination.
  • Transport layer specifies how to provide reliable transfer and the Transmission Control Protocol (TCP) software also provides additional facilities required by higher-level applications.
  • Application layer specifies how applications use the Internet.
probing the internet
Probing the Internet
  • Simplest probing tool is the Packet InterNet Groper, or ping.
  • According to the Internet requirements document [RFC 1122] , every TCP/IP stack should implement such a program.
ping command example
PING Command Example
  • penguin(101)% ping -c5 PING ( from 56(84) bytes of data 64 bytes from ( icmp_seq=1 ttl=235 time=131 ms 64 bytes from ( icmp_seq=2 ttl=235 time=131 ms 64 bytes from ( icmp_seq=3 ttl=235 time=131 ms 64 bytes from ( icmp_seq=4 ttl=235 time=131 ms 64 bytes from ( icmp_seq=5 ttl=235 time=131 ms --- ping statistics --- 5 packets transmitted, 5 received, 0% loss, time 4008ms rtt min/avg/max/mdev = 131.394/131.742/131.978/0.317 ms penguin(102)%
  • -c5 instructs ping to stop after sending five probes
  • summary on the first line indicates an alternative name for the target is, that its IP address is, and it’s sending 56 bytes of data in an 84-byte IP datagram.
  • The next five lines are the responses received. These indicate that there are approximately 20 (= 255 - 235) hops between and, and that the average round-trip time is 131 ms.
what good is ping
What Good Is PING
  • Cons
    • Little info for average user
    • Not good as debug tool
      • Output occurs only when computer responds
      • Fails if network is congested
      • PING cannot determine cause of problem
      • Some companies configure systems to reject pings
  • Pros
    • Determine which part of network is still operating
    • Results help pinpoint failure quickley
  • Determine intermediate computers along the way
  • Uses same arguments as PING (remote computers name or address)
  • Shows how the hops between source and destination.
chapter 3 introduction
Chapter 3 Introduction
  • Use of a network requires programs (and systems) that are “network-aware.”
  • Some applications are usually provided with machines (e.g. web clients, e-mail clients, file sharing).
  • New custom applications must use the interface (API) to the network facilities provided by the system.
  • We will look at a simple API and three sample applications (both the client and the server).
network communication
Network Communication
  • Networks are the mechanisms that transmit data from one point to another.
  • Logically, networks are (or should be) passive, and do not understand, act on, or modify the data being moved.
  • There are two ends of a network communication, each associated with an application program that understands the generation and interpretation of the data being moved across the network.
client server computing
Client-Server Computing
  • The two applications that communicate using a network must locate each other.
  • Typically, one application (the server) starts and then waits for the other application (the client) to contact it.
  • This arrangement is usually called the client-server paradigm, or just client-server computing.
  • The client must, of course, be able to locate the server for this arrangement to work.
addressing internet applications
Addressing Internet Applications
  • Each network server application has a two-part address of the form (computer,application).
  • The computer part of the address identifies the particular computer on which the application is running. This can be provided in symbolic (e.g. or numeric (e.g. form.
  • The application part of the address identifies the particular application. It, too, can be provided symbolically or numerically.
  • When transmitted on a network, the (computer,application) address is always sent in binary.
communication paradigm
Communication Paradigm
  • Most Internet applications follow this basic sequence of operations for communication:
    • The server starts first, and waits for contact from a client.
    • The client contacts the server by specifying its location and requesting communication.
    • The client and the server exchange messages.
    • After they finish, the client and server each send an end-of-file to terminate communication.
  • Functions are provided in the class library on apollo to perform each of these tasks.
an example application program interface
An Example Application Program Interface
  • The term “application program interface,” or API, is used to describe the set of operations available (in a particular programming domain) to a programmer.
  • The simplified API presented in the textbook hides much of the complexity in network programming, but also doesn’t provide the richness of the usual networking API. We will see more details in later chapters.
example api overview
Example API Overview

Operation Meaning

await_contact used by server to wait for a contact

make_contact used by client to contact a server

cname_to_comp translate a computer name to an

equivalent internal binary value

appname_to_appnum translate a program name to an

equivalent internal binary value

send used by client or server to send data

recv used by client or server to receive data

send_eof used by client or server after all data

has been sent.

an intuitive look at the api
An Intuitive Look at the API
  • The application actions usually follow this pattern:
    • The server calls await_contact to wait for contact from a client. The client calls make_contact to establish the connection. [The server is said to be blocked until the contact is made.]
    • Once contact is made, the applications use send and recv to exchange data. [The protocol dictates when each application sends or receives.]
    • Once the data exchange is complete, the client or the server terminates the connection by calling send_eof. The other application detects the termination of the communication when recv returns 0.
api definition data types
API Definition – Data Types
  • There are three data types (in addition to the usual integer, character, and real data types) used in the API:
    • appnum: a binary value used to identify an application [this is really a port number].
    • computer: a binary value used to identify a computer [this is really an Internet Protocol address, or IP address.]
    • connection: a value used to identify one endpoint of a connection between a client and a server [normally this identifies a socket data structure].
api definition await contact
API Definition – await_contact
  • A server calls await_contact to wait for a contact from a client. The function expects one argument of type appnum, and returns a connection which is then used in send, recv, and send_eof functions.

connection await_contact (appnum a)

api definition make contact
API Definition – make_contact
  • A client calls make_contact to establish contact with a server. The arguments identify the computer on which the server is running, and the application number to be contacted. The function returns a connection used for send, recv, and send_eof by the client.

connection make_contact (computer c, appnum a)

api definition appname to appnum
API Definition – appname_to_appnum
  • This function is used to translate from a predefined human-readable name [character string] to a binary application number. Standard application names are defined in the /etc/services file on a UNIX system. It takes a string argument and returns the binary application number.

appnum appname_to_appnum (char *name)

api definition cname to comp
API Definition – cname_to_comp
  • This function translates a symbolic computer name (cname) to the equivalent binary form (which is returned) of type computer.

computer cname_to_comp (char *cname)

api definition send
API Definition – send
  • Send arranges to transmit data (a sequence of n bytes in a char array buf) over an established connection c, returning the number of bytes actually transmitted. The last argument is always 0 in this simplified API.

int send (connection c, char *buf,

int n, 0)

api definition recv
API Definition – recv
  • Recv receives at most n bytes of data from a connection c, placing it in a char array buf, and returning the number of bytes received and stored. Recv will return 0 only when the end of file is reached, and a negative value when an error occurred (e.g. recv without a valid connection).

int recv (connection c, char *buf,

int n)

api definition recvln
API Definition – recvln
  • Recvln reads one line of data (terminated by an end of line character) from a connection c into a char array buf; no more than n-1 bytes will be read (allowing one byte for string termination). Recvln uses recv to read one byte at a time.

int recvln (connection c, char *buf,

int n)

api definition send eof
API Definition – send_eof
  • Send_eof terminates the connection c, returning a negative number if an error occurred.

int send_eof (connection c)

the echo application
The ECHO Application
  • The ECHO application server merely resends each line it receives from a client. The server is started (from a command line) by typing the program name and a selected application number (usually in the range 1025 to 32767).
  • The client application is started by typing its name, the name of the computer on which the server is running, and the same application number.
  • Lines are then read by the client, echoed by the server, and displayed by the client, until an end of file (control-D on UNIX, or control-Z on Windows) is entered.
  • Illustration…
an important observation
An Important Observation
  • If you examine the code for the echo client, you will find that it does not immediately read another line from the keyboard after reading data from the connection. This is because recv only returns as much data as it has actually read.
  • The reason for this is that the underlying network may send a group of data bytes in several different packets. Thus the received data may arrive in pieces with sizes different from those used when the data was sent.
the chat application
The CHAT Application
  • The chat application is similar to the echo application. Here, however, the server displays the received data line and waits for a response from the user on that machine, which is then sent back to the client for display.
  • Either the user at the server machine or the user at the client machine may terminate the chat session by entering an end of file.
  • Illustration…
the web application
The WEB Application
  • Our final example is a simple text-mode web server and browser. Only two web pages are provided by the server: “/” and “/time”. It is easy, however, to extend this application to deliver arbitrary pages stored as files on the server machine.
  • The server and client both use the standard HTTP protocol, and the server delivers HTML documents with appropriate headers. Thus a commercial web browser could be used to contact our server.
  • Illustration…