Difference between _, __ and __xx__ in Python

16 Sep 2010

When learning Python many people don’t really understand why so much underlines in the beginning of the methods, sometimes even in the end like __this__! I’ve already had to explain it so many times, it’s time to document it.

One underline in the beginning

Python doesn’t have real private methods, so one underline in the beginning of a method or attribute means you shouldn’t access this method, because it’s not part of the API. It’s very common when using properties:

class BaseForm(StrAndUnicode):
def _get_errors(self):
    "Returns an ErrorDict for the data provided for the form"
    if self._errors is None:
    return self._errors

errors = property(_get_errors)</code></pre></figure>

This snippet was taken from django source code (django/forms/ This means errors is a property, and it’s part of the API, but the method this property calls, _get_errors, is “private”, so you shouldn’t access it.

Two underlines in the beginning

This one causes a lot of confusion. It should not be used to mark a method as private, the goal here is to avoid your method to be overridden by a subclass. Let’s see an example:

class A(object):
    def __method(self):
        print "I'm a method in A"
def method(self):

a = A() a.method()

The output here is

$ python 
I'm a method in A

Fine, as we expected. Now let’s subclass A and customize __method

class B(A):
    def __method(self):
        print "I'm a method in B"

b = B() b.method()

and now the output is…

$ python
I'm a method in A

as you can see, A.method() didn’t call B.__method() as we could expect. Actually this is the correct behavior for __. So when you create a method starting with __ you’re saying that you don’t want anybody to override it, it will be accessible just from inside the own class.

How python does it? Simple, it just renames the method. Take a look:

a = A()
a._A__method()  # never use this!! please!
$ python
I'm a method in A

If you try to access a.__method() it won’t work either, as I said, __method is just accessible inside the class itself.

Two underlines in the beginning and in the end

When you see a method like __this__, the rule is simple: don’t call it. Why? Because it means it’s a method python calls, not you. Take a look:

>>> name = "igor"
>>> name.len()
>>> len(name)

>>> number = 10 >>> number.add(20) 30 >>> number + 20 30

There is always an operator or native function that calls these magic methods. The idea here is to give you the ability to override operators in your own classes. Sometimes it’s just a hook python calls in specific situations. __init__(), for example, is called when the object is created so you can initialize it. __new__() is called to build the instance, and so on…

Here’s an example:

class CrazyNumber(object):
def __init__(self, n):
    self.n = n

def __add__(self, other):
    return self.n - other

def __sub__(self, other):
    return self.n + other

def __str__(self):
    return str(self.n)

num = CrazyNumber(10) print num # 10 print num + 5 # 5 print num - 20 # 30

Another example:

class Room(object):
def __init__(self):
    self.people = []

def add(self, person):

def __len__(self):
    return len(self.people)

room = Room() room.add("Igor") print len(room) # 1

The documentation covers all these special methods.


Use _one_underline to mark you methods as not part of the API. Use __two_underlines__ when you’re creating objects to look like native python objects or you wan’t to customize behavior in specific situations. And don’t use __just_to_underlines, unless you really know what you’re doing!

 a, b = b, a+b


a, b = b, a+b

is equivalent to:

temp = a
a = b
b += temp

It lets you simultaneously do two calculations without the need of an intermediate/temporary variable.

The difference is that in your second piece of code, when you do the second line b = a+b, you have already modifed a in the previous line which is not the same as the first piece of code.


>>> a = 2
>>> b = 3
>>> a,b
2 3
>>> a,b = b,a
>>> a,b
3 2

On the other hand, if you use the second approach shown in your question:

>>> a = 2
>>> b = 3
>>> a,b
2 3
>>> a = b
>>> b = a
>>> a,b
3 3

class instantiation

The instantiation operation (“calling” a class object) creates an empty object. Many classes like to create objects with instances customized to a specific initial state. Therefore a class may define a special method named __init__(), like this:

def __init__(self): = []

When a class defines an __init__() method, class instantiation automatically invokes __init__() for the newly-created class instance. So in this example, a new, initialized instance can be obtained by:

x = MyClass()

Of course, the __init__() method may have arguments for greater flexibility. In that case, arguments given to the class instantiation operator are passed on to __init__(). For example,


>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

Class and Instance Variables

Generally speaking, instance variables are for data unique to each instance and class variables are for attributes and methods shared by all instances of the class:

class Dog:

    kind = 'canine'         # class variable shared by all instances

    def __init__(self, name): = name    # instance variable unique to each instance

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.kind                  # shared by all dogs
>>> e.kind                  # shared by all dogs
>>>                  # unique to d
>>>                  # unique to e

As discussed in A Word About Names and Objects, shared data can have possibly surprising effects with involving mutable objects such as lists and dictionaries. For example, the tricks list in the following code should not be used as a class variable because just a single list would be shared by all Dog instances:

class Dog:

    tricks = []             # mistaken use of a class variable

    def __init__(self, name): = name

    def add_trick(self, trick):

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks                # unexpectedly shared by all dogs
['roll over', 'play dead']

Correct design of the class should use an instance variable instead:

class Dog:

    def __init__(self, name): = name
        self.tricks = []    # creates a new empty list for each dog

    def add_trick(self, trick):

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
['roll over']
>>> e.tricks
['play dead']

* and **

The syntax is the * and **. The names *args and **kwargs are only by convention but there’s no hard requirement to use them.

You would use *args when you’re not sure how many arguments might be passed to your function, i.e. it allows you pass an arbitrary number of arguments to your function. For example:

>>> def print_everything(*args):
        for count, thing in enumerate(args):
...         print '{0}. {1}'.format(count, thing)
>>> print_everything('apple', 'banana', 'cabbage')
0. apple
1. banana
2. cabbage

Similarly, **kwargs allows you to handle named arguments that you have not defined in advance:

>>> def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print '{0} = {1}'.format(name, value)
>>> table_things(apple = 'fruit', cabbage = 'vegetable')
cabbage = vegetable
apple = fruit

You can use these along with named arguments too. The explicit arguments get values first and then everything else is passed to *args and **kwargs. The named arguments come first in the list. For example:

def table_things(titlestring, **kwargs)

You can also use both in the same function definition but *args must occur before **kwargs.

You can also use the * and ** syntax when calling a function. For example:

>>> def print_three_things(a, b, c):
...     print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)
>>> mylist = ['aardvark', 'baboon', 'cat']
>>> print_three_things(*mylist)
a = aardvark, b = baboon, c = cat

As you can see in this case it takes the list (or tuple) of items and unpacks it. By this it matches them to the arguments in the function. Of course, you could have a * both in the function definition and in the function call.


Assert statements are a convenient way to insert debugging assertions into a program:

assert_stmt ::=  "assert" expression ["," expression]

The simple form, assert expression, is equivalent to

if __debug__:
    if not expression: raise AssertionError

The assert statement exists in almost every programming language. When you do…

assert condition

… you’re telling the program to test that condition, and trigger an error if the condition is false.

In Python, it’s roughly equivalent to this:

if not condition:
    raise AssertionError()


A tuple containing the five components of the version number: major, minor, micro, releaselevel, and serial.

The version_info value corresponding to the Python version 2.0 is (2, 0, 0, 'final', 0). The components can also be accessed by name, so sys.version_info[0] is equivalent to sys.version_info.major and so on.


>>> from Crypto.Cipher import AES
>>> obj ='This is a key123', AES.MODE_CBC, 'This is an IV456')
>>> message = "The answer is no"
>>> ciphertext = obj.encrypt(message)
>>> ciphertext
>>> obj2 ='This is a key123', AES.MODE_CBC, 'This is an IV456')
>>> obj2.decrypt(ciphertext)
'The answer is no'


package Crypto




Appends items from the string, interpreting the string as an array of machine values (as if it had been read from a file using the fromfile() method).



Type code C Type Python Type Minimum size in bytes
'c' char character 1
'b' signed char int 1
'B' unsigned char int 1
'u' Py_UNICODE Unicode character 2 (see note)
'h' signed short int 2
'H' unsigned short int 2
'i' signed int int 2
'I' unsigned int long 2
'l' signed long int 4
'L' unsigned long long 4
'f' float float 4
'd' double float 8


lambda_expr     ::=  "lambda" [parameter_list]: expression old_lambda_expr ::= "lambda" [parameter_list]: old_expression

Lambda expressions (sometimes called lambda forms) have the same syntactic position as expressions. They are a shorthand to create anonymous functions; the expression lambda arguments: expression yields a function object. The unnamed object behaves like a function object defined with

def name(arguments):
    return expression

 reduce(function, iterable[, initializer])

Apply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable. If the optional initializer is present, it is placed before the items of the iterable in the calculation, and serves as a default when the iterable is empty. If initializer is not given and iterable contains only one item, the first item is returned.

Bitwise operators in Python

Operator Meaning Example
& Bitwise AND x& y = 0 (0000 0000)
| Bitwise OR x | y = 14 (0000 1110)
~ Bitwise NOT ~x = -11 (1111 0101)
^ Bitwise XOR x ^ y = 14 (0000 1110)
>> Bitwise right shift x>> 2 = 2 (0000 0010)
<< Bitwise left shift x<< 2 = 42 (0010 1000)


>>>[2] * 3

[2, 2, 2]

int to binary


array.insert(i, x)

Insert a new item with value x in the array before position i. Negative values are treated as being relative to the end of the array.

pip install between python3 and python2

python3 -m pip install -U --force-reinstall pip
python -m pip install -U --force-reinstall pip

will leave you with a pip pointing to python2, a pip2 pointing to python2, and a pip3 pointing to python3.


in python3, print is a function. parenthesis is needed






First, what is a network function? The term typically refers to some component of a network infrastructure that provides a well-defined functional behavior, such as intrusion detection, intrusion prevention or routing.

Historically, we have deployed such network functions as physical appliances, where software is tightly coupled with specific, proprietary hardware. These physical network functions need to be manually installed into the network, creating operational challenges and preventing rapid deployment of new network functions.

A VNF, on the other hand, refers to the implementation of a network function using software that is decoupled from the underlying hardware. This can lead to more agile networks, with significant Opex and Capex savings.

In contrast, NFV typically refers to the overarching principle or concept of running software-defined network functions, independent of any specific hardware platform, as well as to a formal network virtualization initiative led by some of the world’s biggest telecommunications network operators. In conjunction with ETSI, these companies aim to create and standardize an overarching, comprehensive NFV framework, a high-level illustration of which appears below. Notice the diagram highlights VNFs that are deployed on top of NFV infrastructure, which may span more than one physical location.

To summarize, NFV is an overarching concept, while a VNF is building block within ETSI’s current NFV framework.


Application discovery and understanding (ADU) is the process of automatically analyzing artifacts of a software application and determining metadata structures associated with the application in the form of lists of data elements and business rules. The relationships discovered between this application and a central metadata registry is then stored in the metadata registry itself.

P2P and PPP

Peer-to-peer (P2P) computing or networking is a distributed application architecture that partitions tasks or workloads between peers. Peers are equally privileged, equipotent participants in the application. They are said to form a peer-to-peer network of nodes.

Point-to-Point Protocol (PPP) is a data link (layer 2) protocol used to establish a direct connection between two nodes. It connects two routers directly without any host or any other networking device in between.It can provide connection authentication, transmission encryption (using ECP, RFC 1968), and compression.

cryptographic hash function

A cryptographic hash function is a special class of hash function that has certain properties which make it suitable for use in cryptography. It is a mathematical algorithm that maps data of arbitrary size to a bit string of a fixed size (a hash function) which is designed to also be a one-way function, that is, a function which is infeasible to invert. The only way to recreate the input data from an ideal cryptographic hash function’s output is to attempt a brute-force search of possible inputs to see if they produce a match. Bruce Schneier has called one-way hash functions “the workhorses of modern cryptography”.[1] The input data is often called the message, and the output (the hash value or hash) is often called the message digest or simply the digest.

digital signature

A digital signature is a mathematical scheme for demonstrating the authenticity of a digital message or documents. A valid digital signature gives a recipient reason to believe that the message was created by a known sender (authentication), that the sender cannot deny having sent the message (non-repudiation), and that the message was not altered in transit (integrity).

Digital signatures employ asymmetric cryptography. In many instances they provide a layer of validation and security to messages sent through a nonsecure channel: Properly implemented, a digital signature gives the receiver reason to believe the message was sent by the claimed sender. Digital seals and signatures are equivalent to handwritten signatures and stamped seals.Digitally signed messages may be anything representable as a bitstring: examples include electronic mail, contracts, or a message sent via some other cryptographic protocol.

  • key generation algorithm selects a private key uniformly at random from a set of possible private keys and a corresponding public key.
  • A signing algorithm that, given a message and a private key, produces a signature.
  • A signature verifying algorithm that, given the message, public key and signature, either accepts or rejects the message’s claim to authenticity.


When encrypting, you use their public key to write message and they use their private key to read it. Confidentiality

When signing, you use your private key to write message’s signature, and they use your public key to check if it’s really yours. data integrity, message authentication, and non-repudiation.

Symmetric-key algorithms[1] are algorithms for cryptography that use the same cryptographic keys for both encryption of plaintext and decryption of ciphertext. The keys may be identical or there may be a simple transformation to go between the two keys. The keys, in practice, represent a shared secret between two or more parties that can be used to maintain a private information link.[2] This requirement that both parties have access to the secret key is one of the main drawbacks of symmetric key encryption, in comparison to public-key encryption (also known as asymmetric key encryption).[3]



Scope Resolution Operator

In computer programming, the scope of a name binding – an association of a name to an entity, such as a variable – is the part of a computer program where the binding is valid: where the name can be used to refer to the entity.

In computer programming, scope is an enclosing context where values and expressions are associated. The scope resolution operator helps to identify and specify the context to which an identifier refers, particularly by specifying a namespace. The specific uses vary across different programming languages with the notions of scoping. In many languages the scope resolution operator is written “::“.



dBm (sometimes dBmW or decibel-milliwatts) is an abbreviation for the power ratio in decibels (dB) of the measured power referenced to one milliwatt (mW).

The decibel (dB) is a logarithmic unit used to express the ratio of two values of a physical quantity. One of these values is often a standard reference value, in which case the decibel is used to express the level[a] of the other value relative to this reference.

wireless access point (WAP) is a networking hardware device that allows a Wi-Fi compliant device to connect to a wired network. The WAP usually connects to a router (via a wired network) as a standalone device, but it can also be an integral component of the router itself. A WAP is differentiated from a hotspot, which is the physical location where Wi-Fi access to a WLAN is available.

Video Outlets

video producer deliver video to platforms, such as iTunes, Google Play, Hulu etc., pay some fee, then split the revenue with the platforms.




server send public key and other info to client

client send pre-master info encrypted by public key to server, which decrypt it with private key

both start to generate the Master Secret and session keys based on the Pre-Master Secret.

following data exchange are both using session key.




It’s not perfect, and you would usually resort to techniques like the Pimpl Idiom to properly separate interface and implementation, but it’s a good start.


A compilation in C++ is done in 2 major phases:

  1. The first is the compilation of “source” text files into binary “object” files: The CPP file is the compiled file and is compiled without any knowledge about the other CPP files (or even libraries), unless fed to it through raw declaration or header inclusion. The CPP file is usually compiled into a .OBJ or a .O “object” file.
  2. The second is the linking together of all the “object” files, and thus, the creation of the final binary file (either a library or an executable).

Where does the HPP fit in all this process?

A poor lonesome CPP file…

The compilation of each CPP file is independent from all other CPP files, which means that if A.CPP needs a symbol defined in B.CPP, like:

// A.CPP
void doSomething()
   doSomethingElse(); // Defined in B.CPP

// B.CPP
void doSomethingElse()
   // Etc.

It won’t compile because A.CPP has no way to know “doSomethingElse” exists… Unless there is a declaration in A.CPP, like:

// A.CPP
void doSomethingElse() ; // From B.CPP

void doSomething()
   doSomethingElse() ; // Defined in B.CPP

Then, if you have C.CPP which uses the same symbol, you then copy/paste the declaration…


Yes, there is a problem. Copy/pastes are dangerous, and difficult to maintain. Which means that it would be cool if we had some way to NOT copy/paste, and still declare the symbol… How can we do it? By the include of some text file, which is commonly suffixed by .h, .hxx, .h++ or, my preferred for C++ files, .hpp:

// B.HPP (here, we decided to declare every symbol defined in B.CPP)
void doSomethingElse() ;

// A.CPP
#include "B.HPP"

void doSomething()
   doSomethingElse() ; // Defined in B.CPP

// B.CPP
#include "B.HPP"

void doSomethingElse()
   // Etc.

// C.CPP
#include "B.HPP"

void doSomethingAgain()
   doSomethingElse() ; // Defined in B.CPP

How does include work?

Including a file will, in essence, parse and then copy-paste its content in the CPP file.

For example, in the following code, with the A.HPP header:

// A.HPP
void someFunction();
void someOtherFunction();

… the source B.CPP:

// B.CPP
#include "A.HPP"

void doSomething()
   // Etc.

… will become after inclusion:

// B.CPP
void someFunction();
void someOtherFunction();

void doSomething()
   // Etc.

One small thing – why include B.HPP in B.CPP?

In the current case, this is not needed, and B.HPP has the doSomethingElse function declaration, and B.CPP has the doSomethingElse function definition (which is, by itself a declaration). But in a more general case, where B.HPP is used for declarations (and inline code), there could be no corresponding definition (for example, enums, plain structs, etc.), so the include could be needed if B.CPP uses those declaration from B.HPP. All in all, it is “good taste” for a source to include by default its header.


The header file is thus necessary, because the C++ compiler is unable to search for symbol declarations alone, and thus, you must help it by including those declarations.

One last word: You should put header guards around the content of your HPP files, to be sure multiple inclusions won’t break anything, but all in all, I believe the main reason for existence of HPP files is explained above.




cd <ns-3-folder>
./waf configure --enable-examples

when run to this,

need to modify the configure command to use MacPorts version of python:

cd <ns-3-folder>
sudo port select python python27
./waf configure --with-python=/opt/local/bin/python2.7 --enable-examples


Defining a topology in txt file, with

experimental extended versions of TopologyReader classes: AnnotatedTopologyReader and RocketfuelWeightsReader.


if only one route can be chosen, then use

 Choosing forwarding strategy

Otherwise, use

 Set BestRoute strategy




last time using this was long time ago which is why I almost forgot everything about it.

So this time I’ll write it down to help remember it.

  1. display filter & capture filter :capture filter is what packets you really capture and display is what you want to see. We can use the configuration icon on the top left for fast choosing capture filter, Expression icon for display filter.
  2. DSCP:
    Differentiated Services Code Point (DSCP)

    Originally defined as the Type of service (ToS) field. This field is now defined by RFC 2474 (updated by RFC 3168 and RFC 3260) forDifferentiated services (DiffServ). New technologies are emerging that require real-time data streaming and therefore make use of the DSCP field. An example is Voice over IP (VoIP), which is used for interactive data voice exchange.                     DiffServ uses a 6-bit differentiated services code point (DSCP) in the 8-bit differentiated services field (DS field) in the IP header for packet classification purposes. The DS field and ECN field replace the outdated IPv4 TOS field

  3. IntServ specifies a fine-grained QoS system, which is often contrasted with DiffServ’s coarse-grained control system. In order for IntServ to work, all routers along the traffic path must support it. Furthermore, many states must be stored in each router. As a result, IntServ works on a small-scale, but as you scale up to a system the size of the Internet, it is difficult to keep track of all of the reservations.[1]
  4. Per-hop behaviour

    From Wikipedia, the free encyclopedia

    In computer networking, per-hop behaviour (PHB) is a term used in differentiated services (DiffServ) or multiprotocol label switching(MPLS). It defines the policy and priority applied to a packet when traversing a hop (such as a router) in a DiffServ network.

    Rule that governs how packets are handled within a diffserv[1] network is called the Per-Hop Behavior (PHB). PHBs are defined to support the general properties controlled by IP precedence. DSCP Contains 6-bits, PHBs are created (one for each combination of the top 3 bits) of the form bbb000 to match the precedence behaviors and leaves the other DSCP values open where each b may take the value zero or 1.

    DSCP Bit Settings Meaning
    000000 Best effort
    bbb000 Conforms to the requirements of Type of Service queuing precedence
    bbbbb0 Available for standardization
    bbbb11 For experimental of local network usage
    bbbb01 For experimental of local network usage, but may be taken for standardization
    Class selector values
    DSCP Binary Hex Decimal Typical application Examples
    CS0 (Default) 000 000 0x00 0
    CS1 001 000 0x08 8 Scavenger YouTube, Gaming, P2P
    CS2 010 000 0x10 16 OAM SNMP,SSH,Syslog
    CS3 011 000 0x18 24 Signaling SCCP,SIP,H.323
    CS4 100 000 0x20 32 Realtime TelePresence
    CS5 101 000 0x28 40 Broadcast video Cisco IPVS
    CS6 110 000 0x30 48 Network control EIGRP,OSPF,HSRP,IKE
    CS7 111 000 0x38 56


  5. List of IP protocol numbers

    From Wikipedia, the free encyclopedia

    This is a list of IP numbers used in the Protocol field of the IPv4 header and the Next Header field of IPv6 header.

    Decimal Hex Keyword Protocol References
    0 0x00 HOPOPT IPv6 Hop-by-Hop Option RFC 2460
    1 0x01 ICMP Internet Control Message Protocol RFC 792
    2 0x02 IGMP Internet Group Management Protocol RFC 1112
    3 0x03 GGP Gateway-to-Gateway Protocol RFC 823
    4 0x04 IP-in-IP IP in IP (encapsulation) RFC 2003
    5 0x05 ST Internet Stream Protocol RFC 1190, RFC 1819
    6 0x06 TCP Transmission Control Protocol RFC 793
    7 0x07 CBT Core-based trees RFC 2189
    8 0x08 EGP Exterior Gateway Protocol RFC 888
    9 0x09 IGP Interior Gateway Protocol (any private interior gateway (used by Cisco for their IGRP))
    10 0x0A BBN-RCC-MON BBN RCC Monitoring
    11 0x0B NVP-II Network Voice Protocol RFC 741
    12 0x0C PUP Xerox PUP
    13 0x0D ARGUS ARGUS
    14 0x0E EMCON EMCON
    15 0x0F XNET Cross Net Debugger IEN 158
    16 0x10 CHAOS Chaos
    17 0x11 UDP User Datagram Protocol RFC 768
    18 0x12 MUX Multiplexing IEN 90
    19 0x13 DCN-MEAS DCN Measurement Subsystems
    20 0x14 HMP Host Monitoring Protocol RFC 869
    21 0x15 PRM Packet Radio Measurement
    22 0x16 XNS-IDP XEROX NS IDP
    23 0x17 TRUNK-1 Trunk-1
    24 0x18 TRUNK-2 Trunk-2
    25 0x19 LEAF-1 Leaf-1
    26 0x1A LEAF-2 Leaf-2
    27 0x1B RDP Reliable Datagram Protocol RFC 908
    28 0x1C IRTP Internet Reliable Transaction Protocol RFC 938
    29 0x1D ISO-TP4 ISO Transport Protocol Class 4 RFC 905
    30 0x1E NETBLT Bulk Data Transfer Protocol RFC 998
    31 0x1F MFE-NSP MFE Network Services Protocol
    32 0x20 MERIT-INP MERIT Internodal Protocol
    33 0x21 DCCP Datagram Congestion Control Protocol RFC 4340
    34 0x22 3PC Third Party Connect Protocol
    35 0x23 IDPR Inter-Domain Policy Routing Protocol RFC 1479
    36 0x24 XTP Xpress Transport Protocol
    37 0x25 DDP Datagram Delivery Protocol
    38 0x26 IDPR-CMTP IDPR Control Message Transport Protocol
    39 0x27 TP++ TP++ Transport Protocol
    40 0x28 IL IL Transport Protocol
    41 0x29 IPv6 IPv6 Encapsulation RFC 2473
    42 0x2A SDRP Source Demand Routing Protocol RFC 1940
    43 0x2B IPv6-Route Routing Header for IPv6 RFC 2460
    44 0x2C IPv6-Frag Fragment Header for IPv6 RFC 2460
    45 0x2D IDRP Inter-Domain Routing Protocol
    46 0x2E RSVP Resource Reservation Protocol RFC 2205
    47 0x2F GRE Generic Routing Encapsulation RFC 2784, RFC 2890
    48 0x30 MHRP Mobile Host Routing Protocol
    49 0x31 BNA BNA
    50 0x32 ESP Encapsulating Security Payload RFC 4303
    51 0x33 AH Authentication Header RFC 4302
    52 0x34 I-NLSP Integrated Net Layer Security Protocol TUBA
    53 0x35 SWIPE SwIPe IP with Encryption
    54 0x36 NARP NBMA Address Resolution Protocol RFC 1735
    55 0x37 MOBILE IP Mobility (Min Encap) RFC 2004
    56 0x38 TLSP Transport Layer Security Protocol (using Kryptonet key management)
    57 0x39 SKIP Simple Key-Management for Internet Protocol RFC 2356
    58 0x3A IPv6-ICMP ICMP for IPv6 RFC 4443, RFC 4884
    59 0x3B IPv6-NoNxt No Next Header for IPv6 RFC 2460
    60 0x3C IPv6-Opts Destination Options for IPv6 RFC 2460
    61 0x3D Any host internal protocol
    62 0x3E CFTP CFTP
    63 0x3F Any local network
    64 0x40 SAT-EXPAK SATNET and Backroom EXPAK
    65 0x41 KRYPTOLAN Kryptolan
    66 0x42 RVD MIT Remote Virtual Disk Protocol
    67 0x43 IPPC Internet Pluribus Packet Core
    68 0x44 Any distributed file system
    69 0x45 SAT-MON SATNET Monitoring
    70 0x46 VISA VISA Protocol
    71 0x47 IPCU Internet Packet Core Utility
    72 0x48 CPNX Computer Protocol Network Executive
    73 0x49 CPHB Computer Protocol Heart Beat
    74 0x4A WSN Wang Span Network
    75 0x4B PVP Packet Video Protocol
    76 0x4C BR-SAT-MON Backroom SATNET Monitoring
    77 0x4D SUN-ND SUN ND PROTOCOL-Temporary
    78 0x4E WB-MON WIDEBAND Monitoring
    80 0x50 ISO-IP International Organization for Standardization Internet Protocol
    81 0x51 VMTP Versatile Message Transaction Protocol RFC 1045
    82 0x52 SECURE-VMTP Secure Versatile Message Transaction Protocol RFC 1045
    83 0x53 VINES VINES
    84 0x54 TTP TTP
    84 0x54 IPTM Internet Protocol Traffic Manager
    86 0x56 DGP Dissimilar Gateway Protocol
    87 0x57 TCF TCF
    88 0x58 EIGRP EIGRP
    89 0x59 OSPF Open Shortest Path First RFC 1583
    90 0x5A Sprite-RPC Sprite RPC Protocol
    91 0x5B LARP Locus Address Resolution Protocol
    92 0x5C MTP Multicast Transport Protocol
    93 0x5D AX.25 AX.25
    94 0x5E IPIP IP-within-IP Encapsulation Protocol RFC 2003
    95 0x5F MICP Mobile Internetworking Control Protocol
    96 0x60 SCC-SP Semaphore Communications Sec. Pro
    97 0x61 ETHERIP Ethernet-within-IP Encapsulation RFC 3378
    98 0x62 ENCAP Encapsulation Header RFC 1241
    99 0x63 Any private encryption scheme
    100 0x64 GMTP GMTP
    101 0x65 IFMP Ipsilon Flow Management Protocol
    102 0x66 PNNI PNNI over IP
    103 0x67 PIM Protocol Independent Multicast
    104 0x68 ARIS IBM’s ARIS (Aggregate Route IP Switching) Protocol
    105 0x69 SCPS SCPS (Space Communications Protocol Standards) SCPS-TP[1]
    106 0x6A QNX QNX
    107 0x6B A/N Active Networks
    108 0x6C IPComp IP Payload Compression Protocol RFC 3173
    109 0x6D SNP Sitara Networks Protocol
    110 0x6E Compaq-Peer Compaq Peer Protocol
    111 0x6F IPX-in-IP IPX in IP
    112 0x70 VRRP Virtual Router Redundancy Protocol, Common Address Redundancy Protocol (not IANA assigned) VRRP:RFC 3768
    113 0x71 PGM PGM Reliable Transport Protocol RFC 3208
    114 0x72 Any 0-hop protocol
    115 0x73 L2TP Layer Two Tunneling Protocol Version 3 RFC 3931
    116 0x74 DDX D-II Data Exchange (DDX)
    117 0x75 IATP Interactive Agent Transfer Protocol
    118 0x76 STP Schedule Transfer Protocol
    119 0x77 SRP SpectraLink Radio Protocol
    120 0x78 UTI Universal Transport Interface Protocol
    121 0x79 SMP Simple Message Protocol
    122 0x7A SM Simple Multicast Protocol draft-perlman-simple-multicast-03
    123 0x7B PTP Performance Transparency Protocol
    124 0x7C IS-IS over IPv4 Intermediate System to Intermediate System (IS-IS) Protocol over IPv4 RFC 1142 and RFC 1195
    125 0x7D FIRE Flexible Intra-AS Routing Environment
    126 0x7E CRTP Combat Radio Transport Protocol
    127 0x7F CRUDP Combat Radio User Datagram
    128 0x80 SSCOPMCE Service-Specific Connection-Oriented Protocol in a Multilink and Connectionless Environment ITU-T Q.2111 (1999)
    129 0x81 IPLT
    130 0x82 SPS Secure Packet Shield
    131 0x83 PIPE Private IP Encapsulation within IP Expired I-D draft-petri-mobileip-pipe-00.txt
    132 0x84 SCTP Stream Control Transmission Protocol
    133 0x85 FC Fibre Channel
    134 0x86 RSVP-E2E-IGNORE Reservation Protocol (RSVP) End-to-End Ignore RFC 3175
    135 0x87 Mobility Header Mobility Extension Header for IPv6 RFC 6275
    136 0x88 UDPLite Lightweight User Datagram Protocol RFC 3828
    137 0x89 MPLS-in-IP Multiprotocol Label Switching Encapsulated in IP RFC 4023
    138 0x8A manet MANET Protocols RFC 5498
    139 0x8B HIP Host Identity Protocol RFC 5201
    140 0x8C Shim6 Site Multihoming by IPv6 Intermediation RFC 5533
    141 0x8D WESP Wrapped Encapsulating Security Payload RFC 5840
    142 0x8E ROHC Robust Header Compression RFC 5856
    143-252 0x8F-0xFC UNASSIGNED
    253-254 0xFD-0xFE Use for experimentation and testing RFC 3692
    255 0xFF Reserved.

Streaming Media Protocol…/What-Is-a-Streaming-Media-Protocol-84496.aspx



To follow all this, I recommend adding these fields as columns:

  • TCP length (tcp.len)
  • Sequence number (tcp.seq)
  • Next expected sequence number (tcp.nxtseq)
  • Acknowledgment number (tcp.ack)

There the follwing length now:
Frame length: Total length of the Frame, including the Padding Fields (if present and needed) of the Ethernet Layer
Captured Length: Frame Length which is captured (Interresting if a filter has been used)
IP.TotalLength: Total Packet Length. from IP-Header until Layer 7 payload ends
TCP.SegmentLegth: Resulting TCP Payload and only calculated by Wireshark
TCP.HeaderLength: Is the length of the TCP Header, because header size is variabel

Identification of TCP stream in wireshark







How does NDN differ from CDNs?

A content distribution network (CDN) is a good example of service that is implemented as an overlay on today’s TCP/IP architecture to meet the demand for scalable content distribution, when the same content is requested by many users. CDN customers tend to be relatively large content owners who are willing to pay for higher performance delivery of their content. Content producers without CDN services would face load and performance challenges if/once their content becomes popular.

CDNs operate at the application layer, which gives rise to two issues: how to get customer content requests into the CDN system (a common solution is for the CDN provider to host DNS service for the domain name of the content it serves); and mapping each request to the nearest CDN node serving the content. NDN works directly at network layer and naturally forwards Interest packets along the best paths to the desired data.

Are there any commonalities between IP and NDN architectures?

Both architectures share the same hourglass shape, with the IP/NDN layer as the narrow waist.
Both send datagrams.
Both follow end-to-end principle.
Both use their own namespace for data delivery (i.e. IP uses IP addresses to deliver datagrams between IP nodes; NDN uses the application name space to deliver datagrams between NDN nodes).

What will the role of ICN be on the Internet in 20 years? Will it be the dominant paradigm of communications?

It’s the dominant paradigm now. YouTube, Netflix, Amazon, iTunes, …, are pure ICN and account for more than half of the world’s internet traffic. But today’s ICN-over-IP is inefficient and unsecure because the information-centric overlay is a poor match to the Internet’s conversationally-oriented underlay. The Internet is also already mostly mobile devices (whose users are also content-focused), which the IP architecture does not support well.  Finally, the IP architecture was not designed to naturally support secure communication or secure data distribution. Rather than ignore the growing incongruity between the architecture and global use of the Internet, we are inspired to design, develop, and incrementally deploy an architecture that `catches up’ with the dominant paradigm of communications today.

This architectural incongruity is analogous to the one between packet-oriented IP overlay and circuit-oriented telephony underlay during the Internet’s first 20 years. Imagine the 1990 question “What will be the role of the internet in the global telephony system 20 years from now?”  We now know the answer was “the global telephony system became just one of many applications running over IP internet,” i.e., the overlay became the underlay because it did more, better. We predict we could substitute `Internet’ for `telephony system’ and `NDN/ICN’ for `IP internet’ to move the clock forward 20 years.