Python实现SIP电话：VoIP通信指南

需积分: 10 5 浏览量更新于2024-07-23 收藏 588KB PDF 举报

标题 "manifest mtiso" 描述了C#的一个VoIP电话示例，该主题聚焦于使用Session Initiation Protocol (SIP) 实现互联网电话（VoIP）功能。作者Kundan Singh正在撰写一篇关于在客户端-服务器模式和对等模式下，如何用Python实现可扩展且健壮的SIP通信的指南。这本文档还强调了它是"work in progress"，计划作为开源软件39Peers项目的一部分提供，且包含来自IETF RFCs和互联网草案的部分文本，以解释和帮助实施。在这个C#的VoIP实现中，关键知识点包括： 1. **SIP基础知识**：SIP是一种用于建立、管理、修改和终止多媒体通信会话的应用层协议，它允许VoIP设备间的通信。C#代码示例将展示如何利用SIP协议来建立和控制语音通话，包括注册到SIP服务器、发起呼叫、接收呼叫以及处理媒体流。 2. **C#编程技术应用**：开发者会学习如何在C#中处理SIP消息，如INVITE、ACK、BYE等，并可能涉及socket编程或者使用专门的SIP库（如SIPSorcery或Nancy SIP）来简化开发过程。 3. **客户端-服务器模式与对等模式**：文档区分了这两种架构，前者通常适用于集中式系统，而后者则更适用于分布式环境，如P2P网络。理解这两种模式在SIP通信中的区别和适用场景至关重要。 4. **可扩展性和健壮性设计**：作者关注的是如何编写代码以支持高并发、故障恢复和负载均衡，以确保系统的稳定运行，这对于VoIP服务至关重要。 5. **版权和许可**：所有材料的版权归Kundan Singh所有，需要获得他的明确许可才能复制或使用文档内容。文档中引用的RFCs和互联网草案的版权规定也遵循相应的知识产权规则。 6. **开源与贡献**：文档是作者开源项目的一部分，意味着读者可以通过访问源代码和参与社区，参与到这个VoIP实现的进一步发展和优化中。这个C# VoIP示例提供了一个实际的平台，让开发者学习如何使用SIP技术构建网络电话应用，并深入了解协议背后的原理和实现策略，同时体验了跨平台、开放源码项目的协作精神。

- 16 -

self.__dict__[n.lower().strip()] = _unquote(v.strip())

After the parsing is completed, we may want to inspect some of the unstructured header values and store the

values in a more structured form. For instance, the

CSeq header value has two parts: the number and the

method name.

CSeq: 1 INVITE

For programming convenience, we can store the individual parts separately as follows. We also canonicalizes

the value so as to remove more than one spaces between the number and the method name, if needed.

elif name == 'cseq':

n, sep, self.method = map(lambda x: x.strip(), value.partition(' '))

self.number = int(n); value = n + ' ' + self.method

Now that we have completed the parsing step, we can create the constructor which takes an optional string

for the value. The constructor removes any extra surrounding white-spaces from the value before parsing it.

The header name is converted to lower-case if applicable.

def __init__(self, value=None, name=None):

self.name = name and _canon(name.strip()) or None

self.value = self._parse(value.strip(), self.name and self.name.lower() or None)

Formatting

Formatting a Header object has two semantics: either you can format only the value or the complete header

line. We implement two different methods,

str and repr, to achieve these functions. Correspondingly, the

object can be converted to string in different contexts differently.

The value is formatted as follows. If the header type is comma-included or unstructured, then the value

property is the actual value string representation which can be returned, otherwise the parameters (or rest)

needs to be appended to the value. When appending the parameters, all indices from the local associative

array are used except for pre-defined indices of

name, value and _viauri.

def __str__(self):

name = self.name.lower()

rest = '' if ((name in _comma) or (name in _unstructured)) \

else (';'.join(map(lambda x: self.__dict__[x] and '%s=%s'%(x.lower(),self.__dict__[x]) or x, filter(lambda x:

x.lower() not in ['name','value', '_viauri'], self.__dict__))))

return str(self.value) + (rest and (';'+rest) or '');

The repr method just returns the header “name: value” where value is formatted using the str method.

- 18 -

if self._viaUri.port == None: self._viaUri.port = 5060

If the rport parameter is present in the header, the URI port is changed to the rport value if present, and

not changed if

rport value is not present.

if 'rport' in self:

try: self._viaUri.port = int(self.rport)

except: pass # probably not an int

If the type is not a reliable transport type, and maddr parameter is present then the URI host is changed to

maddr value, otherwise if received parameter is present then URI host is changed to received parameter

value.

if type not in ['tcp','sctp','tls']:

if 'maddr'in self: self._viaUri.host = self.maddr

elif 'received' in self: self._viaUri.host = self.received

We implement this function using the viaUri property as follows.

@property

def viaUri(self):

if not hasattr(self, '_viaUri'):

if self.name != 'Via': raise ValueError, 'viaUri available only on Via header'

proto, addr = self.value.split(' ')

type = proto.split('/')[2].lower() # udp, tcp, tls

self._viaUri = URI('sip:' + addr + ';transport=' + type)

if self._viaUri.port == None: self._viaUri.port = 5060

if 'rport' in self:

try: self._viaUri.port = int(self.rport)

except: pass # probably not an int

if type not in ['tcp','sctp','tls']:

if 'maddr'in self: self._viaUri.host = self.maddr

elif 'received' in self: self._viaUri.host = self.received

return self._viaUri

Before continuing it may be worthwhile to test our function for correctness.

>>> print Header('SIP/2.0/UDP example.net:5090;ttl=1', 'Via').viaUri

sip:example.net:5090;transport=udp

>>> print Header('SIP/2.0/UDP 192.1.2.3;rport=1078;received=76.17.12.18;branch=0', 'Via').viaUri

sip:76.17.12.18:1078;transport=udp

>>> print Header('SIP/2.0/UDP 192.1.2.3;maddr=224.0.1.75', 'Via').viaUri

sip:224.0.1.75:5060;transport=udp

IMPLEMENTING SIP TELEPHONY

- 19 -

Splitting header line

From RFC3261 p29 – HTTP/1.1 also specifies that multiple header fields of the same field name whose value is

a comma-separated list can be combined into one header field. That applies to SIP as well, but the specific rule

is different because of the different grammars. Specifically, any SIP header whose grammar is of the form

header = "header-name" HCOLON header-value *(COMMA header-value)

allows for combining header fields of the same name into a comma- separated list.

Each header field consists of a field name followed by a colon (":") and the field value. The formal grammar for a

message-header allows for an arbitrary amount of whitespace on either side of the colon.

The SIP message parser need to first divide the headers portion into individual header lines, extract the

header name and value from the header line and finally invoke the

Header constructor to construct

individual header object. If a single header line contains multiple comma “,” separated header values, then

those individual header values need to be constructed independently.

We define a class method to perform this task. The method takes a string and returns a tuple with two values:

the first is the header name, and the second is an array of

Header objects.

@staticmethod

def createHeaders(value):

name, value = map(str.strip, value.split(':', 1))

return (_canon(name), map(lambda x: Header(x, name), value.split(',') if name.lower() not in _comma else [value]))

This can be tested as follows.

>>> print Header.createHeaders('Event: presence, reg')

('Event', [Event: presence, Event: reg])

Now that we have implemented the class, we can do basic testing as follows:

>>> print repr(Header('"Kundan Singh" <sip:kundan@example.net>', 'To'))

To: "Kundan Singh" <sip:kundan@example.net>

>>> print repr(Header('"Kundan"<sip:kundan99@example.net>', 'To'))

To: "Kundan" <sip:kundan99@example.net>

>>> print repr(Header('Sanjay <sip:sanjayc77@example.net>', 'fRoM'))

From: "Sanjay" <sip:sanjayc77@example.net>

>>> print repr(Header('application/sdp', 'conTenT-tyPe'))

Content-Type: application/sdp

>>> print repr(Header('presence; param=value;param2=another', 'Event'))

Event: presence;param=value;param2=another

>>> print repr(Header('78 INVITE', 'CSeq'))

CSeq: 78 INVITE

- 20 -

Message

A Message object is a representation of a SIP message. Unlike other SIP stacks that define various

individual message types, separate classes for first line, etc., in Python we use dynamic properties to easily

implement those features. In particular, the same class implements both the request and response. The

attributes such as

method or response.are valid for request or response, respectively.

Even though we would like to have the attribute syntax for accessing the header from a message, certain

header names cannot be a Python attribute name. For example, “Content-Length” with an embedded dash

cannot be an attribute. Thus, we implement both the attribute as well as container access for the headers in a

message. The header names are case in-sensitive. Accessing the header that doesn’t exist in the message

gives

None instead of exception. This creates cleaner source code, instead of having to catch exceptions

everywhere. The following definition allows us to create a generic object that can hold name value pairs and

allow access using both attribute access and container access syntax.

class Message(object):

def __getattr__(self, name): return self.__getitem__(name)

def __getattribute__(self, name): return object.__getattribute__(self, name.lower())

def __setattr__(self, name, value): object.__setattr__(self, name.lower(), value)

def __delattr__(self, name): object.__delattr__(self, name.lower())

def __hasattr__(self, name): object.__hasattr__(self, name.lower())

def __getitem__(self, name): return self.__dict__.get(name.lower(), None)

def __setitem__(self, name, value): self.__dict__[name.lower()] = value

def __contains__(self, name): return name.lower() in self.__dict__

There are certain pre-defined attributes: method, uri, response, responsetext, protocol and

body.

_keywords = ['method','uri','response','responsetext','protocol','_body','body']

A SIP header can be either a single-instance header or a multiple-instance header. There are only a few

single-instance headers. By default, a header is treated as multiple-instance. The difference between single

and multiple instance headers is that we can expose a single

Header as the value of a single instance header,

whereas we expose an

list of Header objects as the value of a multiple instance header.

_single = ['call-id', 'content-disposition', 'content-length', 'content-type', 'cseq', 'date', 'expires', 'event', 'max-forwards',

'organization', 'refer-to', 'referred-by', 'server', 'session-expires', 'subject', 'timestamp', 'to', 'user-agent']

Parsing

From RFC3261 p.27 – The start-line, each message-header line, and the empty line MUST be terminated by a

carriage-return line-feed sequence (CRLF). Note that the empty line MUST be present even if the message-

body is not.

Parsing a SIP message is an important method in the Message class. The first step in parsing a SIP message is

splitting the string across “\r\n\r\n” so that the second part becomes the message body text, and the first part

contains the first line as well as the headers.

剩余137页未读，继续阅读

egondadalt

粉丝: 0
资源: 1

Python实现SIP电话：VoIP通信指南

解决manifest导致xp sp2崩溃的补丁 mt.exe

Java程序创建Manifest文件

manifest manifest

manifest

MANIFEST

Manifest详解

apiary-manifest:apiary.manifest 的演示

manifest for java:8 not found: manifest unknown: manifest unknown

android manifest

启动docker容器出现manifest for java:8 not found: manifest unknown: manifest unknown

最新资源