Raw Sockets

What are Raw Sockets?

Memungkinkan Anda untuk memotong lapisan TCP/UDP. Mengirim/menerima paket Anda sendiri, dengan header Anda sendiri. Anda perlu melakukan semua protokol pengolahan pada user level.

Typical Uses
Pesan-pesan ICMP ping menghasilkan ICMP echo permintaan dan menerima ICMP echo balasan. Protokol routing berpagar OSPF mengimplementasikan protokol routing. Menggunakan paket IP dengan protokol ID 89tidak didukung oleh kernel. Hacking Menghasilkan paket-paket TCP/UDP Anda sendiri dengan header palsu

Raw socket creation

Only root can open a raw socket.
sockfd = socket(AF_INET, SOCK_RAW, proto)

where proto is IPPROTO_RAW, IPPROTO_ICMP etc.

Raw socket output

As usual sendto(), sendmsg() etc.
IP_HDRINCL option
Specifies whether the process or the kernel builds the IP header.
/* allow process to build IP header */ int on=1; setsockopt( sockfd, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on))

Raw socket input

Normally using recvfrom() Conditions for a packet to match raw socket
If protocol parameter was specified, only packets with that protocol value are delivered. If bind() was called on raw socket, only packets destined to bound IP address are delivered. If connect() was called, only packets from connected address are delivered.

Which protocol types are delivered?

TCP and UDP never reach raw sockets
Kernel IP stack handles these Linux implementation is an exception.

All ICMP except

ICMP echo request Timestamp request Mask request

All IGMP
All other protocols that kernel doesn't understand
Such as OSPF

Exercise

Write a simple Hello exchange program using raw sockets that implements your own protocol on top of IP.

Java
Reference Book Thinking in Java by Bruce Eckel Book is online at http://www.mindview.net/books/TIJ

Levels of abstraction
Object oriented languages (C++, Java) Abstracting the problem as object interactions Abstracting the machine model

Imperative languages (C, FORTRAN, ALGOL)

Assembly language

Low-level machine details

Machine

Object
An object has
State (internal data) Behavior (methods that operate on data) Identity (object can be addressed uniquely)

Objects
Class defines properties of a set of similar objects.
Think of it as type of the object

Protection boundaries define what object state is visible to others. Inheritance allows a new class to inherit properties of an earlier class without re-defining them. Interface defines what requests others can make to a particular object

Parent class

Interface

Child classes

Primitive Data types

boolean - false char - \u0000 (null) byte - (byte)0 short - (short)0 int - 0 long - 0L float - 0.0f double -0.0d

Creating a class
class Circle {
public : Circle(int x, int y, float r) {} void draw(){} Methods void erase(){} void move(){} private : int x_; Fields int y_; float radius_;

Creating an object
Circle c = new Circle(10,20,5);

c.draw(); c.move(); c.erase();

Inheritance
abstract class Shape {
public : Shape(int x, int y) { x_ = x; y_ = y; }
abstract void draw(); abstract void erase(); abstract void move();

protected : int x_; int y_;

Inheritance
class Circle extends Shape { Circle(int x,int y,float r){ super(x,y); radius_ = r; } void draw() {} void erase(){} void move(){}

protected : float radius_;

Inheritance
class Square extends Shape { Square(int x,int y,float w){ super(x,y); width_ = r; } void draw() {} void erase(){} void move(){}

protected : float width_;

void doStuff(Shape s) { s.erase(); // ... s.draw(); } Circle c = new Circle(); Square s = new Square(); Line l = new Line();

doStuff(c); doStuff(s); doStuff(l);

Interfaces
interface DrawObject {
// automatically public void draw(); void erase(); void move(); // Compile-time constant: int SOME_CONST = 5; // static & final

class Shape {
public : Shape(int x, int y) { x_ = x; y_ = y; } protected : int x_; int y_;

class Circle extends Shape implements DrawObject { Circle(int x,int y,float r){ super(x,y); radius_ = r; } void draw() {} void erase(){} void move(){} protected : float radius_;

class Square extends Shape implements DrawObject { Square(int x,int y,float w){ super(x,y); width_ = r; } void draw() {} void erase(){} void move(){} protected : float width_;

static members
static fields or methods have one instance across all object instances
class X { static int i = 0; } x1 = new X(); x2 = new X(); x1.i++; x2.i++; System.out.println(Result = + x2.i); Result = 2

final member/class
final class X {
} Final classes cannot be extended.

class X {
final int m(); } Final methods cannot be overridden.

int mthd(final MyClass mc) {}

Final arguments cannot be modified.

final int MY_CONST = 10;

Final fields/references are constants

Things you should learn from TIJ

Packaging your classes - Chapter 5
Java I/O system - Chapter 11 Error handling with exceptions - Chapter 10

Applets - Chapter 14

Using Standard Java Packages

java import java.lang.*;
public class HelloDate {
public static void main(String[] args) {
System.out.println("Hello, it's: "); System.out.println(new Date());

}
}

Some other packages

java.net java.rmi java.io java.applet java.awt java.math