P2P-SIP

network abstraction layer unit · 39 Peers

  rtmp-payload := enc-type[1B] | type[1B] | remaining
  enc-type := is-intra[4b] | codec-type[4b]
  is-intra := 1 if intra and 2 if non-intra
  codec-type := 7 for H.264/AVC

  remaining for config := version[1B] | profile-idc[1B]
      | profile-compat[1B] 
      | level-idc[1B]
      | length-flag[1B]
      | sps-count[1B] | sps0 ...
      | pps-count[1B] | pps0 ...
  length-flag := 0[6b] | value[2b] where value + 1 is length-size
  sps-count := 0[3b] | count[5b] where count is number of sps
  pps-count := number of pps elements
  sps(n) := length[2B] | sps
  pps(n) := length[2B] | pps

  remaining-picture := delay[3B] | nalu0 | nalu1 ...
  nalu(n) := length | nalu
  length := number in length-size bytes
  nalu := NAL unit as per H.264

  nalu := nal-flags[1B] | encoded-data
  nal-flags := forbidden[1b] | nri[2b] | nal-type [5b]

To fragment:
  let encoded-data = fragment0 | fragment1 | fragment2...
  encoded-data of fragment(n) := orig-nal-flags[1B] | fragment(n)
  orig-nal-flags := start[1b] | end[1b] | ignore[1b] 
     | orig-nal-type[5b]
  start := 1 if first fragment else 0
  end := 1 if last fragment else 0

To aggregate:
  encoded-data of aggregate := nalu0 | nalu1 | nalu2 ...
  nalu(n) := length[2B] | orig-nalu(n)

packet := scrambled-session-id | encrypted-part
scrambled-session-id = a^b^c
session-id = x^y^z
"Adobe Systems 02"
raw-part := checksum | network-layer-data | padding
len(padding) = 16*N - len(network-layer-data) - 1
network-layer-data = flags | timestamp | timestamp-echo | chunks ...
--------------------------------------------------------------------
flags      meaning
--------------------------------------------------------------------
0000 1011  setup/handshake
0100 1010  in-session no timestamp-echo (server to Flash Player)
0100 1110  in-session with timestamp-echo (server to Flash Player)
xxxx 1001  in-session no timestamp-echo (Flash Player to server)
xxxx 1101  in-session with timestamp-echo (Flash Player to server)
--------------------------------------------------------------------

int(time * 1000/4) & 0xffff = 46586
chunk = type | size | payload
 initiator (client)                target (server)
  |-------initiator hello---------->|
  |<------responder hello-----------|

 initiator (client)                forwarder (server)                     target (client)
|-------initiator hello---------->|                                       |
|                                 |---------- forwarded initiator hello-->|
|                                 |<--------- ack ----------------------->|
|<------------responder hello---------------------------------------------|

 initiator (client)                redirector (server)                     target (client)
|-------initiator hello---------->|                                 
|<------responder redirect--------|
|-------------initiator hello-------------------------------------------->|
|<------------responder hello---------------------------------------------|

"Adobe Systems 02"
---------------------------------
type  meaning
---------------------------------
\x30  initiator hello
\x70  responder hello
\x38  initiator initial keying
\x78  responder initial keying
\x0f  forwarded initiator hello
\x71  forwarded hello response

\x10  normal user data
\x11  next user data
\x0c  session failed on client side
\x4c  session died
\x01  causes response with \x41, reset keep alive
\x41  reset times keep alive
\x5e  negative ack
\x51  some ack
---------------------------------

number = 0000dddd dddccccc ccbbbbbb baaaaaaa (in binary)
where A=aaaaaaa, B=bbbbbbb, C=ccccccc, D=ddddddd are the four 7-bit numbers

0aaaaaaa (1 byte)  if B = C = D = 0
0bbbbbbb 0aaaaaaa (2 bytes) if C = D = 0 and B != 0
0ccccccc 0bbbbbbb 0aaaaaaa (3 bytes) if D = 0 and C != 0
0ddddddd 0ccccccc 0bbbbbbb 0aaaaaaa (4 bytes) if D != 0

initiator-hello payload = first | epd | tag
epd = epd-type | epd-value
responder-hello payload = tag-echo | cookie | responder-certificate
certificate = \x01\x0A\x41\x0E | dh-public-num | \x02\x15\x02\x02\x15\x05\x02\x15\x0E
initiator-initial-keying payload = initiator-session-id | cookie-echo
| initiator-certificate | initiator-component | 'X'
y1 = g ^ x1 % p
y2 = g ^ x2 % p
shared-secret = y1 ^ x2 % p
responder-nonce = \x03\x1A\x00\x00\x02\x1E\x00\x81\x02\x0D\x02 | responder's DH public number
decode key = HMAC-SHA256(shared-secret, HMAC-SHA256(responder nonce, initiator nonce))[:16]
encode key = HMAC-SHA256(shared-secret, HMAC-SHA256(initiator nonce, responder nonce))[:16]

responder-initial-keying payload = responder session-id | responder's nonce | 'X'
encode key = HMAC-SHA256(shared-secret, HMAC-SHA256(responder nonce, initiator nonce))[:16]
decode key = HMAC-SHA256(shared-secret, HMAC-SHA256(initiator nonce, responder nonce))[:16]

forwarded initiator hello payload := first | epd | transport-address | tag
transport-address := flag | ip-address | port-number
forwarded-hello-response = transport-address | transport-address | ...
normal-user-data payload := flags | flow-id | seq | forward-seq-offset | options | data
bit   meaning
0x80  options are present if set, otherwise absent
0x40
0x20  with beforepart
0x10  with afterpart
0x08
0x04
0x02  abandon
0x01  final

next-user-data := flags | data
s = socket(...);
write(s, ...);    /* use it like a file */

s = new Socket();
s.addEventListener("socketData", handlerFunction);

cam = Camera.getCamera("default")
# will cam be the current snapshot of default-camera or will it automatically
# change when default-camera changes?

task1: data = yield multitask.recv(sock, timeout=10)
task2: yield multitask.send(sock, somedata)
 POST /login/kundan@example.net      -- new registration
request-body: {"contact": "sip:kundan@192.1.2.3:5062"}
response-body: {"url": "/login/kundan@example.net", "id": 1, "expires": 3600}

PUT /login/kundan@example.net/1     -- registration refresh
request-body: "sip:kundan@192.1.2.3:5062"

DELETE /login/kundan@example.net/1  -- unregister

GET /login/kundan@example.net       -- get list of contact locations
response-body: [{"id": 1, "contact": "sip:kundan@192.1.2.3:5062", ...},...]

 POST /call             -- create a new call context
request-body: {"subject": "some discussion topic", ...}
response-body: {"id": "123", "url": "/call/123" }

POST /call/123         -- join a call
request-body: {"url": "/login/kundan@example.net", "session": "rtsp://...", ...}
response-body: {"id": 2, "url": "/call/123/2", ...}

GET /call/123          -- get participant list and call info
response-body: {"subject": "some discussion topic",
                "children": [{"url": "/call/123/2", "session": "rtsp://..."}]
               }

 SEND /login/alok@example.net     -- send call invitation
request-body: {"command": "invite", "url": "/call/123", "id": 567}

SEND /login/alok@example.net     -- cancel an invitation
request-body: {"command": "cancel", "url": "/call/123", "id": 567}

SEND /login/kundan@example.net   -- sending a response
 request-body: {"command": "reject", "url": "/call/123", "id": 567, "reason": ...}

 GET /call/123          -- keep track of membership information
response 1:  ...      -- initial membership information
response 2:  ...      -- any addition or deletion in the membership

GET /login/kundan@example.net -- keep track of presence updates
response 1:  ...      -- initial presence information
response 2:  ...      -- subsequent presence updates.

 POST /user                            -- signup with a new account
request-body: {"email": "kundan@example.net", ...}
response-body: {"id": "kundan@example.net", "url": "/user/kundan@example.net" }

POST /user/kundan@example.net/message  -- send offline messages (voice/video mail)
 request-body: {"url": "rtsp://..."}

GET /user/kundan@example.net/message   -- retrieve list of messages
 response-body: [{"url": "rtsp://...", ...]

  from app import sipapi
  agent = sipapi.Agent(sipaddr=('192.168.1.3', 5060), transports=('udp',)).start()

  def route(event):
    if len(str(event)) > 8192: return event.action.reject(513, 'Message Overflow')
    if event.method == 'INVITE' and event.uri.user == 'anyone':
      event.location = URI('sip:someone@somewhere.com')
      return event.action.proxy()
    ...
  agent.attach("incoming", route)
  sipapi.run()

def redirect_to_voicemail(event):
    event.location = URI('sip:jones@voicemail.example.com')
    event.action.redirect()

def proxy_then_voicemail(event):
    if event['From'].uri.host.endswith('example.com'):
        event.location = URI('sip:jones@example.com')
        e = event.action.proxy(timeout=10)
        if e in ('busy', 'noanswer', 'failure'): redirect_to_voicemail(event)
    else: transfer_to_voicemail(event)

basic.addEventListener('incoming', proxy_then_voicemail)

from sipapi import *
import re

_debug  = True  # enable debug trace
open(('67.93.12.18', 5060)) # listen on this ip:port for incoming packets

def route(event):
    # sanity check section
    if event['Max-Forwards'] and int(event['Max-Forwards'].value) <= 0:
        return event.action.reject(code=483, reason='Too many hops')
    if len(str(event)) > 8192:
        return event.action.reject(code=513, reason='Message overflow')
    # this is used by sipsak to monitor the health of server
    if event.method == 'OPTIONS':
        if event['From'].uri.user == 'sipsak' and not event.uri.user:
            return event.action.accept()
    ...
basic.addEventListener('incoming', route)

run()  # the loop to process the SIP listening point

# @implements RFC2617 (HTTP auth)

# @implements RFC2617 P3L16-P3L25

 while not queue.empty():
   msg = queue.remove(0)
   dispatch(msg)   # calls the event handler for msg

 button.addEventListener('click', clickHandler);
 ...
 function clickHandler(event:Event):void {
   ...
 }

 timer.addEventListener('timer', function(event:TimerEvent):void {
   ... // process timer event
 }

 result = socket.connect(...)
 result.wait()
 if result:
   ... # connection successful

 data, addr = yield multitask.recvfrom(socket, ...)
 yield multitask.sendto('response', addr)

a = DHT()
a['key1'] = 'value1'
print a['key1']
del a['key1']

a['kundan@example.net'] = 'kns10@192.1.2.3:5062'
print a['henning@example.net']   # prints all contacts of henning

a['key1'] += 'value1'
a['key2'] += 'value2'
print a['key1']  # print a list of values
a['key1'] -= 'value1' # remove specific key1-value1
del a['key1']    # remove all values for key1

a = DHT(privatekey=...)   # supply the private key of the owner
print a['key1']           # print all values for given key
print a(owner=...)['key1']    # print values only by given owner

so = DistributedSharedObject.getRemote(privatekey=...)
so.setProperty('key1', 'value1') # sets the key1-value1 pair
so.retrieve('key2')        # initiates get
so.addEventListener('sync', syncHandler)
so.addEventListener('propertyChange', changeHandler)
function syncHandler(event:SyncEvent):void {
... # put is completed
}
function changeHandler(event:PropertyChangeEvent):void {
if (event.property == 'key2') # get is completed
  trace(so.data['key2'])
}

d = DHT(privatekey=..., timeout=3600)   # default TTL of one hour

d = DHT(net=..., .privatekey=..., timeout=...) # use the given connectivity (net) object

s0 = ServerSocket(...)  # a P2P node is created
s0.bind(identity=..., credentials=....) # node joins the P2P network

s1 = s0.connect(remote=...) # connect to the given remote identity
s2, remote = s0.accept()    # receive an incoming connection from remote

s1.send(data=..., timeout=...)
data = s1.recv()

s0.sendto(data=..., remote=...)  # send to specific peer
data, remote = s0.recvfrom(timeout=...)

s0.sendto(data=..., key=...)
data, remote, local = s0.recvfrom(...)
if local == s0.sockname:  # received for this node identifier
...
else:  # received to the given key presumably close this node
key = local

s1.close()  # close the connection
s0.close()  # remove the node

s3 = s0.join(group=...)  # join a given group
s3.send(data=...)        # send to every node in the group
s3.sendany(data=...)     # send to at most one node in the group
data, remote, key = s3.recv()  # receive a multicast or anycast data

Rate	multitask	gevent
8 kHz	4.8-5.1%	3.1-3.2%
16 kHz	6.2-6.5%	4.0-4.1%

Media	#players	multitask	gevent
Audio	0	2.2%	1.3%
Audio	1	3.5%	1.8%
Audio	2	4.5%	2.1%
Audio	3	5.5%	2.5%
Audio+Video	0	3.0-3.9%	1.4-1.7%
Audio+Video	1	4.2-4.7%	2.1%
Audio+Video	2	5.5-6.3%	2.7%
Audio+Video	3	7.0-7.6%	3.1%

Function	Protocols
Structured data encoding	XML, ASN.1, RFC822, others
Audio encoding	G.711, G.723.1, G.722, G.726, G.728, G.729, MP3, Speex, Nellymoser, AMR, Silk, GIPS, etc.
Video encoding	H.261, H.263, H.264, MPEG, Sorenson, Vidyo, etc.
Media transport	RTP/RTCP, SRTP, ZRTP, Skype, IAX, RTMP, RTMFP
Rendezvous	SIP, H.323, Skype, Stratus/RTMFP
Session description	SDP, H.245, Jingle
Session negotiation	SIP/SDP, H.245, Jingle, Skype, RTMFP
Call signaling and control	SIP, H.225/Q.931, Skype, IAX, MGCP, SCCP (Skinny), RTMFP
Streaming media control	RTSP, RTMP
Session announcement	SAP
Connectivity	ICE/STUN/TURN, Skype, RTMFP
Remote Procedure Call	SOAP, XMLRPC, REST, RTMP
Programming calls	CGI, CPL, CCXML, MSCML
Programming voice dialog	VoiceXML
Instant messaging	XMPP, SIMPLE, MSRP
Presence	XMPP, SIMPLE
Shared resource access	REST, XMPP, XCAP
Shared state	XMPP, RTMP, HTTP

	SIP	XMPP
Purpose	Provide rendezvous for session establishment and negotiation where the actual session is independent, e.g., over RTP media transport.	Provide a streaming pipe for structured data exchange between group of clients with the help of server(s), e.g., for instant messaging and presence
Protocol	Text-based request-response protocol similar to HTTP, where core attributes are signaled using headers, and additional data using message body, e.g., session description of capabilities.	XML-based client-server protocol to create a streaming pipe on which it sends request, response, indication or error using XML stanza between client and server, and between servers.
Transport	Usually implemented in connection-less UDP as well as connection-oriented TCP transport. Also works over secure TLS transport.	Works over connection-oriented TCP or TLS transport.
Connection	A user-agent is both client and server, hence can send or receive connections, in case of TCP or TLS. This does not work well with NATs and firewalls, hence extensions are defined to use reverse connections when server wants to send message to client.	The client initiates the connection to the server, which works well with NATs and firewalls. Additionally, extensions are defined such as BOSH to carry XMPP stanza over HTTP to work with very restricted firewalls

Beauty	Software project
Natural beauty is, well, natural, whereas cosmetics give artificial sense of beauty.	Open source software are built when some motivated developer feels like building something, where as commercial software are mostly built by engineers who are paid and forced to build.
Natural beauty is long lasting, whereas makeup wear down after few hours or days.	Open source software lives longer, whereas commercial projects tend to get out beaten by competition sooner or later.
You are born beautiful and don't have to pay for natural beauty, whereas cosmetics cost money, big money.	Open source software are mostly free, whereas you have to pay for commercial software.
It is hard for salesman to sell fruits and water to enhance your beauty, whereas it is easy for salesman to sell cream and nail-polish. Sometimes these advertisements are deceptive.	Usually you don't find people advertising their open source work much, whereas companies have dedicated sales team to sell the commercial product. Sometimes these sales pitch are deceptive.
Natural beauty is usually open and does not hide scars, whereas cosmetics are meant to hide scars, marks, etc., to give a (false) sense of beauty.	Open source software are open source code, where developers can jump right in the code and see things. Commercial software hides the source code, and instead presents documentation, power points, sales pitch, etc., to give a (false) sense of what is inside and actually hiding what is inside (source code).
Natural beauty does not require support. On the other hand if you are putting a nail polish, you will need a remover; if you are putting on make up, you will need to remove it before bed.	Open source software usually comes with no support. If you have it, you own it, and you put up with it. Commercial software usually comes with (expensive) support system. If you have it, you need to keep paying for bug fixes and upgrades. Otherwise it will harm you sooner or later.

P2P-SIP

Translating H.264 between Flash Player and SIP/RTP

Understanding RTMFP Handshake

Three Problems in Interoperating with H.264 of Flash Player

The Philosophy of Open Source

Internet Video Communication: Past, Present and Future

Flash-based audio and video communications in the cloud

Voice and Video Communications on Web

A Proposal for Reference Implementation Repository of SIP-related RFCs

RESTful communication over WebSocket

WebRTC vs Flash Player

Performance of siprtmp: multitask vs gevent

Implementing video conferencing and text chat using Channel API

What is Flash Media Gateway?

How to extend HTML5 for real-time video communication?

How to conduct a technical interview for software engineer?

Why do P2P-SIP?

Theory vs practice of SIP-based VoIP

Tips for implementing application protocols

Scalability vs Performance

Lessons in starting a software project

Flash-VideoIO: Flash-based audio and video communication

Distributed Systems Development: Client vs Server

Client

Server

What Great Programmers think?

FAQ on using Flash Player to make phone calls

Project ideas in P2P-SIP

Software API Design

Systems Software Research

REST, Flash Player, Flex

REST and SIP

REST, RESTful and restlite

Protocol Jungle of Internet multimedia communication

SIP vs XMPP or SIP and XMPP?

Reliability and scalability in P2P-SIP

Security in P2P-SIP

The (in)security of Flash Player's crossdomain

The Internet Video City

High level description

Novel idea

Product design ideas

The big picture

Beauty of open source

Programmable SIP server

How does Google video chat work in gmail?

Problems in RTMP

APIs for SIP applications

Why Open Source?

Documenting RFC implementations

Problems due to NATs and firewalls

RTMFP vs SIP

Why does client-server video conference fail?

Asynchronous Internet Programming

Programming languages for implementing SIP

P2P API

Welcome to 39 peers!

memcached

Business out of P2P-SIP

Data format and interface for external P2P mode

Structured vs unstructured P2P or Why we chose DHT for P2P-SIP?

New internet-drafts

Thunderbird as a deployment vehicle

Email based identity in P2P-SIP

Using an external DHT as a SIP location service

SIP-using-P2P vs P2P-over-SIP

2 P2P or Not 2 P2P?

First post: initial set of references