TELE402
Internetworking
TELE402 Lecture 1 Protocol Layering
1
People
• Lecturer
Dr. Zhiyi Huang
Email: hzy@cs.otago.ac.nz
Phone: 479-5680
Office: 1.26 Owheo Building
• Teaching Assistant
Kai-Cheung Leung
Email: kcleung@cs.otago.ac.nz
Phone: 479-7852
Office: 2.55 Owheo Building
TELE402 Lecture 1 Protocol Layering
2
Assessment
• Labs
– 20%
• Assignments
– 30%
• Exam (Have to get 40 out of 100 to pass)
– 50%
TELE402 Lecture 1 Protocol Layering
3
Textbooks
Internetworking with TCP/IP, Vol. 1, Principles, Protocols, and
Architectures (5th ed), D.E. Comer, Prentice Hall
Unix Network Programming, Vol. 1, The Sockets Networking
API (3rd ed), W.R. Stevens, B. Fenner, A.M. Rudoff,
Addison Wesley
TELE402 Lecture 1 Protocol Layering
4
About the Course
• Lectures & reading
– Internetworking with TCP/IP
– Socket API
• Labs
– Programming network applications
• Assignments
TELE402 Lecture 1 Protocol Layering
5
Overview
• This lecture
–
–
–
–
The C programming language
Source: A good C programming book
Protocol layering
Source: Chapter 10 for reading
• Next lecture
– TCP and UDP
TELE402 Lecture 1 Protocol Layering
6
Functions - 1
• Remember:
•
•
•
•
no classes or methods in C.
C is case-sensitive.
Functions are the main abstraction mechanism and
represent an operation to be performed more than
once.
Functions have a name, arguments and a return
type. If a function does not produce a value, it has
a return type of void.
The actions of a function are expressed in the
body that is enclosed in curly braces -- “{…}”
A function is invoked whenever the call operator
(“()”) is applied to the function’s name.
TELE402 Lecture 1 Protocol Layering
7
Functions - 2
• Every C program must have a function
named, “main”. This function is called to
run the program. The main function returns
an int or void.
#include <stdio.h>
int main()
{
printf(“hello, world\n”);
}
TELE402 Lecture 1 Protocol Layering
8
Functions - 3
• There are many standard functions already
defined that are part of the C language.
These functions are stored in libraries.
• The first line of the previous program
(#include <stdio.h>) tells the preprocessor
to include the standard input/output library.
TELE402 Lecture 1 Protocol Layering
9
Functions - 4
int area( int length, int width )
{
return length * width;
}
• Functions must be declared before they are called.
• An expression including a call to the area function:
2 * area( 5, 7) + 25;
TELE402 Lecture 1 Protocol Layering
10
Functions – 5 (scope)
• Variables that are declared inside a function are
called, ‘automatic’, and are local to that function.
• It is possible to define ‘external’ variables that are
external to all functions. The scope of an external
variable lasts from the point at which it is declared to
the end of the file. If an external variable is to be
used and has been defined in a different source file,
then an extern declaration is required.
TELE402 Lecture 1 Protocol Layering
11
Functions – 6 (scope)
• Automatic variables are so-named, because
they appear and disappear automatically
when a function is called.
• The values of function parameters are also
automatic. They are copies of the values of
the variables that were passed to the
function in a function call. This is known
as ‘call-by-value’ parameter passing.
TELE402 Lecture 1 Protocol Layering
12
Example
#include <stdio.h>
int sum( int a, int b);
// function prototype at the start of the file
int main()
{
int x = 4, y = 5;
int total = sum( x, y );
// function call
printf( “The sum of 4 and 5 is %d”, total);
}
int sum( int a, int b ) // call-by-value
{
return( a + b );
}
TELE402 Lecture 1 Protocol Layering
13
Memory and addresses
int x = 5, y = 10;
float f = 12.5, g = 9.8;
char c = ‘z’;
(the addresses are at 2100, 2104, etc.)
5
2100
10
2104
TELE402 Lecture 1 Protocol Layering
12.5
2108
9.8
2112
z
2116
14
Pointers - 1
• A variable can contain a value of a data type,
such as an integer or a float.
• It can also contain a memory address - it can
contain the address of another variable.
• float x;
float *xaddr
// data variable
// pointer variable
x
xaddr
any float
2100
2104
some address
TELE402 Lecture 1 Protocol
Layering
15
Pointers - 2
xaddr = &x;
// & = address-of operator
x
xaddr
???
2100
2100
2104
*xaddr = 4.4;
// * = dereference operator
x
4.4
xaddr
2100
2100
2104
TELE402 Lecture 1 Protocol
Layering
16
Pointers - 3
x = 3.3;
x
xaddr
3.3
2100
2100
2104
Now xaddr “points to” x. If x has its value
changed, the dereferencing of xaddr will
yield that new value.
TELE402 Lecture 1 Protocol Layering
17
Pointers - 4
int x = 1, y = 8;
int *ip, *iq;
ip = &x;
y = *ip;
*ip = 6;
iq = ip;
//
//
//
//
ip now points to x
y is now 1
x is now 6;
iq points to what ip points to
TELE402 Lecture 1 Protocol Layering
18
Pointer arithmetic
• int i, j, k;
int *ip;
ip = &i;
*ip = *ip + 2;
ip = ip + 2;
//
//
//
//
add 2 to i
add to the address of
i, which is the
address ip contains.
The addition of 2 to a pointer increases the
value of the address it contains by the size of
two objects of its type.
TELE402 Lecture 1 Protocol Layering
19
Why use pointers?
There’s a problem here:
#include <stdio.h>
void swap( int, int );
main()
{
int num1 = 5, num2 = 10;
swap( num1, num2 );
printf(“num1 = %d and num2 = %d\n”, num1, num2);
}
void swap(int n1, int n2)
{
int temp;
// passed by value
temp = n1;
n1 = n2;
n2 = temp;
}
TELE402 Lecture 1 Protocol Layering
20
Use of pointers helps
#include <stdio.h>
void swap( int*, int* );
main()
{
int num1 = 5, num2 = 10;
swap( &num1, &num2 );
printf(“num1 = %d and num2 = %d\n”, num1, num2);
}
void swap( int *n1, int *n2 ) // passed by ‘reference’
{
int temp;
temp = *n1;
*n1 = *n2;
*n2 = temp;
}
TELE402 Lecture 1 Protocol Layering
21
Basic input/output
• If you want to use the standard input/output
library, you must have #include <stdio.h>
before the first usage.
• The simplest function reads one character from the
standard input (usually the keyboard):
int getchar( void );
(It returns the next input character each time it is called.)
• int putchar( int c )
puts the character c on the standard output,
which is usually the screen.
TELE402 Lecture 1 Protocol Layering
22
Formatted output
• printf is somewhat complicated, but enables you to
produce formatted output.
int printf ( char *format, arg1, arg2, … )
• The format string contains two types of objects: ordinary
characters (which are just copied to the output stream) and
special conversion specifications. Each conversion begins
with a ‘%’. ‘\’ is used for special characters.
• Recall:
printf(“num1 = %d and num2 = %d\n”, num1, num2);
TELE402 Lecture 1 Protocol Layering
23
Formatted input
• The function scanf is the input analog to
printf and uses many of the same conversion
facilities (in the opposite direction).
int scanf( char *format, arg1, arg2, … )
• Note that each of the input arguments must be a
pointer indicating where the converted input is
supposed to be stored.
TELE402 Lecture 1 Protocol Layering
24
Type conversion
• At the machine level, we just have a collection of
bits.
• Changing one predefined type to another will
change some properties, but not the underlying
bits.
• Some conversions are ‘safe’ and some are
‘unsafe’.
• The programmer can request a conversion by
performing a ‘cast’.
TELE402 Lecture 1 Protocol Layering
25
Casting
• There are two ways to request a cast:
– type (expr)
– (type) expr
• What happens when we do this?
– double (int (3.14159) );
• Some conversions are safe on some machines, but
not on others (it depends on the word size of the
machine), because an int is usually the same size
as either a short or a long, but not both.
TELE402 Lecture 1 Protocol Layering
26
Implicit (automatic) conversions
• Assigning a value to an object converts the value to the type
of that object.
void ff( int );
int val = 3.14159;// converts to int 3
ff( 3.14159 );
// converts to int 3
• The widest data type in an arithmetic expression is the target
conversion type:
val + 3.14159;
//  double
(but val is still an int)
TELE402 Lecture 1 Protocol Layering
27
Pointer conversions
int ival;
int *pi = 0;
char *pc = 0;
void *pv; // can convert others to this,
// but a void* pointer cannot
// be dereferenced directly.
pv = pi;
// ok
pc = pv;
// ok
*pc = *pv;
// error
TELE402 Lecture 1 Protocol Layering
28
Arrays - 1
• An array is a collection of ordered data items, all belonging
to the same type.
• For example, declare:
int values[9];
values[0] = 107;
values[5] = 33;
• The first array index is
always 0.
TELE402 Lecture 1 Protocol Layering
values[0]
values[1]
values[2]
values[3]
values[4]
values[5]
values[6]
values[7]
values[8]
107
33
29
Arrays - 2
#include <stdio.h>
void main(void)
{
int myary[12];
int index, sum = 0;
// 12 cells
// Initialize array before use
for (index = 0; index < 12; index++)
{
myary[index] = index;
}
for (index = 0; index < 12; index++)
{
sum += myary[index]; // sum array elements
}
printf( “The sum is %d”, sum );
}
TELE402 Lecture 1 Protocol Layering
30
Arrays - 3
•We can have multidimensional arrays:
int points[3][4];
points[1][2];
•What is points[1,2]? (wrong!)
•Initialize arrays:
int counters[5] = { 0, 0, 0, 0, 4 };
char letters[] = { ‘a’, ‘b’, ‘c’, ‘d’, ‘e’ };
Notice the second example. If the array is initialized, you don’t
have to specify the array size. The compiler will figure it out.
TELE402 Lecture 1 Protocol Layering
31
Example: convert number base
int main ()
{
char base_digits[16] =
{‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’,
‘8’, ‘9’, ‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’ };
int converted_number[64];
long int num_to_convert;
int next_digit, base, index = 0;
// get the number and base
printf(“Number to be converted? “);
scanf(“%ld”, &num_to_convert);
printf(“Base? “);
scanf(“%i”, &base);
TELE402 Lecture 1 Protocol Layering
32
// convert to the indicated base
do
{
converted_number[index] = num_to_convert % base;
++index;
num_to_convert = num_to_convert / base;
}
while ( num_to_convert != 0 );
// display the results in reverse order
printf(“Converted number = “);
for ( --index; index >= 0; --index )
{
next_digit = converted_number[index];
printf(“%c”, base_digits[next_digit]);
}
printf(“\n”);
}
TELE402 Lecture 1 Protocol Layering
33
More about arrays
• The name of the array by itself, is
like a pointer to the first element
of the array
• This means that we can write
*(v+i) and that has exactly the same
meaning as v[i]. (In fact when the
C compiler sees v[i] , it converts it
to *(v+i).)
• But there is one difference -- an array
name is not a variable.
TELE402 Lecture 1 Protocol Layering
v
v[0]
v[1]
v[2]
v[3]
v[4]
v[5]
‘H’
‘e’
‘l’
‘l’
‘o’
‘!’
34
Character strings
• We can write
char word[] = { ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘!’ };
or
char word[] = { ‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘!’, ‘\0’ };
• The special character at the end is useful for searching
down the end of character strings to find the end point.
• The second declaration can be duplicated by
char word[] = “Hello!”;
Character string constants in C are automatically
terminated by the null (‘\0’) character. What is the length
of this string array?
TELE402 Lecture 1 Protocol Layering
35
Character strings
• Function to concatenate two character strings:
void concat( char result[], char str1[], char str2[])
{
int i, j;
for( i=0; str1[i] != ‘\0; ++i )
result[i] = str1[i];
for( j=0; str2[j] != ‘\0; ++j )
result[i+j] = str2[j];
result[i+j] = ‘\0’;
}
TELE402 Lecture 1 Protocol Layering
36
Useful string functions
•
•
•
•
•
•
•
•
char *strcat(s1, s2) – append s2 onto s1
char *strncat(s1,s2, n) – append only n characters
char *strchr (s, c) – search s for character c
int strcmp (s1, s2) – compare s1, s2
char *strcpy (s1, s2) – copy s2 to s1
char *strrchr (s, c) – search s for last occurrence of c
int strstr (s1, s2) – search s1 for first occurrence of s2
int strlen (s) – count number of characters in s
TELE402 Lecture 1 Protocol Layering
37
Arrays
• When an array (or character string) is passed to a function,
it is passed by reference.
int main()
{
void concat( char result[], char str1[], char str2[])
char s1[] = { “Hoo “};
char sw[] = { “Ha!” };
char se[20];
concat(s3, s1, s2);
printf(“%s\n”, s3);
}
TELE402 Lecture 1 Protocol Layering
38
Arrays and strings
• Why does this work for copying strings?
while (*p++ = *q++)
• C performs no array boundary checks.
This means that you can overrun the end of
an array, without the compiler complaining.
This is the cause of many runtime errors!!!
TELE402 Lecture 1 Protocol Layering
39
Structs - 1
#include <stdio.h>
struct birthday
{
int month;
int day;
int year;
}; // note semicolon
int main() {
struct birthday bd;
bd.day=1; bd.month=1; bd.year=1977;
printf(“My birthday is %d/%d/%d”, bd.day, bd.month, bd.year);
}
TELE402 Lecture 1 Protocol Layering
40
Structs - 2
struct person
{
char name[80];
int age;
float height;
struct
{
int month;
int day;
int year;
} birth;
};
// elements can be different types
// embedded struct
struct person me;
struct person class[60];
me.birth.year=1977;
class[0].name=“Jack”;
class[0].birth.year = 1971;
. . .
TELE402 Lecture 1 Protocol Layering
41
Structs - 3
• So structs are like records (in Pascal) or
classes in Java (without methods, though).
• When structs are passed to functions as
arguments, they are passed by value, unlike
arrays, which are passed by reference.
TELE402 Lecture 1 Protocol Layering
42
Dynamic memory allocation
• The C compiler automatically allocates memory
for the variables that are declared.
• But sometimes we need to allocate memory during
runtime, as we need it.
• malloc is a memory allocation function. It takes
one argument: the number of bytes to allocate. It
returns a pointer to void, so you have to cast it to
what’s been allocated.
• sizeof is an operator that is useful here. It tells
you the size of a data type.
TELE402 Lecture 1 Protocol Layering
43
Dynamic memory allocation
• Suppose you want to allocate enough
memory to store 1,000 integers. You can
int *intptr
intptr = (int *) malloc (1000 * sizeof (int));
The cast
TELE402 Lecture 1 Protocol Layering
44
Memory management
• After you are finished with the memory
space allocated to a pointer q using malloc,
you should free it up by calling:
free(q);
This will release the memory space
allocated to q.
TELE402 Lecture 1 Protocol Layering
45
Operations on Files
• Open a file before you use it
– fp = fopen(“t.txt”, “r”);
• Read data from an opened file
– fread(buffer, 1024, 2, fp);
• Write data into an opened file
– fwrite(data, 512, 2, fp);
• Close an opened file
– fclose(fp);
TELE402 Lecture 1 Protocol Layering
46
Low-level file operations
• open, close, read, write, ioctl
–
–
–
–
–
open(char *name, int flags);
close(int fd);
read(int fd, void *buf, size_t count);
write(int fd, void *buf, size_t count);
ioctl(int fd, int request, char *argp);
• Use “man 2 func” to find out the details.
TELE402 Lecture 1 Protocol Layering
47
Protocol Layering
• Why layering?
–
–
–
–
–
Hardware failure
Network congestion
Packet delay or loss
Data corruption
Data duplication and reordering
TELE402 Lecture 1 Protocol Layering
48
Layering principle
• Layering principle
– Layered protocols are designed so that layer n
at the destination receives exactly the same
object sent by layer n at the source
• Pros and cons
– Complexity, process time, memory usage
– Modularity, simplicity, interoperability,
robustness, security, cost effective
TELE402 Lecture 1 Protocol Layering
49
Layered models
• ISO OSI model
– Seven layers
• TCP/IP model
– Five layers
• PDU and SDU
– Protocol data unit: payload and meta-data
(headers)
– Service data unit: PDU that has been passed
down to the lower layer
– PDU of a layer is the SDU of the layer below.
TELE402 Lecture 1 Protocol Layering
50
PDUs in TCP/IP
• Application layer
– Messages, request/response
• Transport layer
– UPD datagrams, TCP segments
• Network layer
– IP packets
• Data link layer
– Data frames (Ethernet frames)
TELE402 Lecture 1 Protocol Layering
51
Multiplexing/demultiplexing
• Multiplexing
– All data streams are placed into the same network entity
for transfer
• Demultiplexing
– Separate the different streams at the receiver end
• Data link layer
– IP module, ARP module, RARP module
• IP layer
– TCP, UDP, ICMP, SCTP, DCCP
• Transport (Socket) layer based on ports
– smtpd, sshd, httpd, …
TELE402 Lecture 1 Protocol Layering
52
Kernel/user space
• Application is in user space
• Socket, TCP, UDP, IP, data link (network
drivers) are in the kernel space.
• Applications access network protocols
through socket API (system calls)
TELE402 Lecture 1 Protocol Layering
53