diff --git a/LICENSE b/LICENSE
index 06dd9b2..2679ed0 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,625 +1,625 @@
-# Copyright 2010-2014 AG Projects
+# Copyright 2010-2016 AG Projects
# http://ag-projects.com
License
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
diff --git a/README b/README
index 2257f70..6b06cb9 100644
--- a/README
+++ b/README
@@ -1,217 +1,214 @@
SylkServer
----------
-Copyright (c) 2010-2015 AG Projects
-http://ag-projects.com
-
Main author: Saul Ibarra
Mentorship: Adrian Georgescu
Contributors: Denis Bilenko, Dan Pascu
Home page: http://sylkserver.com
License
-------
SylkServer is licensed under GNU General Public License version 3. A copy of
the license is available at http://www.fsf.org/licensing/licenses/gpl-3.0.html
Description
-----------
SylkServer allows creation and delivery of rich multimedia applications
accessed by SIP Clients, XMPP endpoints and Web applications. The server
supports SIP and XMPP signaling, RTP, MSRP and WebRTC media planes, has
built in capabilities for creating multiparty conferences with wideband
Audio, IM/ File Transfers and can be easily extended with other custom
applications by using Python language.
Deployment Scenarios
--------------------
SylkServer is typically deployed behind a SIP Proxy that is designed to
route the inbound and outbound traffic, handle the authentication,
authorization and accounting.
SylkServer can also be deployed as multimedia SIP conference server on a
private network to serve SIP clients on the same LAN by using bonjour mode.
Blink for MacOSX can be used for automatic discovery of SylkServer instances
in the neighborhood.
Features
--------
SIP Signaling
- TLS, TCP and UDP transports
- INVITE and REFER
- SUBSCRIBE/NOTIFY
- Bonjour mode
NAT Traversal
- SIP Outbound
- ICE clients
- MSRP Relay clients
- MSRP ACM clients
Audio
- Wideband (Opus, G722 and Speex)
- Narrowband (G711 and GSM)
- SRTP encryption (SDES and ZRTP key-exchanges)
- Hold/Unhold
- RTP timeout
- DTMF handling
Video
- H.264 and VP8 codecs
- SRTP encryption (SDES and ZRTP key-exchanges)
Instant Messaging
- MSRP protocol
- CPIM envelope
- Is-composing
- Delivery reports
File Transfer
- MSRP protocol
- Progress reports
- Conference-info extension
- Conference room persistent
Conferencing
- Wideband RTP mixer
- MSRP switch
- XMPP MUC
- Multiparty screensharing
- Conference event package
XMPP Gateway
- Server to Server mode
- IM (MSRP sessions and SIP Messages)
- Presence (SIMPLE and XMPP)
WebRTC Gateway
See README.webrtc file.
Applications
------------
When a request arrives at SylkServer, an application is selected depending
on the Request URI. The selection mechanism is described in detail in the
sample configuration file config.ini.sample.
Conference
SylkServer allows SIP end-points to create ad-hoc conference rooms by
sending INVITE to a random username at the hostname or domain where the
server runs. Other participants can then join by sending an INVITE to the
same SIP URI used to create the room. The INVITE and subsequent re-INVITE
methods may contain one or more media types supported by the server. Each
conference room mixed audio, instant messages and uploded files are
dispatched to all participants. One can remove or add participants by
sending a REFER method to the conference URI.
If a participant sends a file to the SIP URI of the room, the server will
accept it, store it for the duration of the conference and offer it to all
participants either present at that moment, or offer it on demand to those
that have joined the conference at a later moment.
Using an extension to MSRP chat protocol, the server provides also
multi-party screen sharing capability.
XMPP Gateway
SylkServer can act as a transparent inter-domain gateway between SIP and
XMPP protocols. This can be used by a SIP service provider to bridge out to
external XMPP domains or to receive incoming chat messages and Jingle audio
sessions from remote XMPP domains to its local SIP users. In a similar
fashion, a XMPP service provider can use the gateway to bridge out to
external SIP domains and handle incoming chat requestes from SIP domains to
the XMPP users it serves.
A media session or a presence session initiated by an incoming connection on
the XMPP side is translated into an outgoing request on the SIP side and the
other way around. To make this possible, proper SIP or XMPP records must
exists into the DNS zone for the domain that needs the gateway service.
WebRTC gateway
This application can be used to bridge audio/video calls between SIP clients
and Web applications. Any SIP service can be used and a simple to use
client API is provided for developing web pages that include such
functionality. This application supports transparently any audio/video
codec negotiated by the end-points.
See https://webrtc.sipthor.net for a working example.
Standards
---------
The server implements relevant features from the following standards:
- SIP (RFC3261) and related RFCs for DNS, ICE and RTP
- MSRP protocol RFC4975
- MSRP relay extension RFC4976
- MSRP File Transfer RFC5547
- MSRP switch RFC7701
- MSRP Alternative Connection Model RFC6135
- Indication of Message Composition RFC3994
- CPIM Message Format RFC3862
- Conference event package RFC4575
- A Framework for Conferencing with SIP RFC4353
- Conferencing for User Agents RFC4579
- Conferencing for User Agents RFC4579
5.1 INVITE: Joining a Conference Using the Conference URI - Dial-In
5.2 INVITE: Adding a Participant by the Focus - Dial-Out
5.5 REFER: Requesting a Focus to Add a New Resource to a Conference
5.11 REFER with BYE: Requesting a Focus to Remove a Participant from a Conference
- XMPP core (RFC 6120) http://xmpp.org/rfcs/rfc6120.html
- XMPP extensions http://xmpp.org/xmpp-protocols/xmpp-extensions
- Instant Messaging and Presence http://xmpp.org/rfcs/rfc6121.html
- Interworking between the Session Initiation Protocol (SIP) and the
Extensible Messaging and Presence Protocol (XMPP):
- Presence: RFC7248
- IM: RFC7572
- Chat: RFC7573
- Multi-party chat: RFC7702
- WebRTC standards http://www.w3.org/TR/webrtc/
Support
-------
The project is developed and supported by AG Projects. The support is
provided on a best-effort basis. "best-effort" means that we try to solve
the bugs you report or help fix your problems as soon as we can, subject to
available resources.
To request support you must the use SIP Beyond VoIP mailing list:
http://lists.ag-projects.com/mailman/listinfo/sipbeyondvoip
For commercial support contact AG Projects http://ag-projects.com
Credits
-------
Special thanks to NLNET http://nlnet.nl for sponsoring most of the efforts
behind this project.
diff --git a/setup.py b/setup.py
index b0be9bc..dafc711 100755
--- a/setup.py
+++ b/setup.py
@@ -1,42 +1,39 @@
#!/usr/bin/python
-# Copyright (C) 2010-2012 AG Projects. See LICENSE for details
-#
-
import glob
import os
import re
from distutils.core import setup
def get_version():
return re.search(r"""__version__\s+=\s+(?P['"])(?P.+?)(?P=quote)""", open('sylk/__init__.py').read()).group('version')
def find_packages(toplevel):
return [directory.replace(os.path.sep, '.') for directory, subdirs, files in os.walk(toplevel) if '__init__.py' in files]
def get_resource_files():
for root, dirs, files in os.walk('resources'):
yield (os.path.join('share/sylkserver', root[10:]), [os.path.join(root, f) for f in files])
setup(name = "sylkserver",
version = get_version(),
author = "AG Projects",
author_email = "support@ag-projects.com",
url = "http://sylkserver.com",
description = "SylkServer - An Extensible SIP Application Server",
classifiers = [
"Development Status :: 5 - Production/Stable",
"Intended Audience :: Service Providers",
"License :: GNU General Public License 3",
"Operating System :: OS Independent",
"Programming Language :: Python"
],
packages = find_packages('sylk'),
scripts = ['sylk-server'],
data_files = [('/var/lib/sylkserver', []),
('/etc/sylkserver', glob.glob('*.ini.sample')),
('/etc/sylkserver/tls', glob.glob('resources/tls/*.crt'))] + \
list(get_resource_files())
)
diff --git a/sylk/__init__.py b/sylk/__init__.py
index 470a892..d702411 100644
--- a/sylk/__init__.py
+++ b/sylk/__init__.py
@@ -1,8 +1,7 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details
"""SylkServer"""
__version__ = '3.1.0'
configuration_filename = "config.ini"
diff --git a/sylk/accounts.py b/sylk/accounts.py
index 5120d69..ba04fb2 100644
--- a/sylk/accounts.py
+++ b/sylk/accounts.py
@@ -1,76 +1,74 @@
-# Copyright (C) 2014-present AG Projects. See LICENSE for details.
-#
from application.system import host
from sipsimple.account import Account, AccountManager
from sipsimple.configuration import SettingsObject
from sipsimple.configuration.datatypes import SIPAddress
from sipsimple.core import Engine, Route, SIPURI
from sylk.configuration import SIPConfig
__all__ = ['DefaultAccount']
class DefaultContactURIFactory(object):
def __init__(self):
self.username = 'sylkserver'
def __getitem__(self, key):
if isinstance(key, tuple):
# The first part of the key might be PublicGRUU and so on, but we don't care about
# those here, so ignore them
_, key = key
if not isinstance(key, (basestring, Route)):
raise KeyError("key must be a transport name or Route instance")
transport = key if isinstance(key, basestring) else key.transport
parameters = {} if transport=='udp' else {'transport': transport}
if SIPConfig.local_ip not in (None, '0.0.0.0'):
ip = SIPConfig.local_ip.normalized
elif isinstance(key, basestring):
ip = host.default_ip
else:
ip = host.outgoing_ip_for(key.address)
if ip is None:
raise KeyError("could not get outgoing IP address")
port = getattr(Engine(), '%s_port' % transport, None)
if port is None:
raise KeyError("unsupported transport: %s" % transport)
uri = SIPURI(user=self.username, host=ip, port=port)
uri.parameters.update(parameters)
return uri
class DefaultAccount(Account):
"""
Subclass of Accoutn which doesn't start any subsystem. SylkServer just
uses it as the default account for all applications as a settings object.
"""
__id__ = SIPAddress('default@sylkserver')
id = property(lambda self: self.__id__)
enabled = True
def __new__(cls):
with AccountManager.load.lock:
if not AccountManager.load.called:
raise RuntimeError("cannot instantiate %s before calling AccountManager.load" % cls.__name__)
return SettingsObject.__new__(cls)
def __init__(self):
super(DefaultAccount, self).__init__('default@sylkserver')
self.contact = DefaultContactURIFactory()
@property
def uri(self):
return SIPURI(user='sylkserver', host=SIPConfig.local_ip.normalized)
def _activate(self):
pass
def _deactivate(self):
pass
diff --git a/sylk/applications/__init__.py b/sylk/applications/__init__.py
index fa7a2a5..3c45d78 100644
--- a/sylk/applications/__init__.py
+++ b/sylk/applications/__init__.py
@@ -1,353 +1,351 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details
-#
__all__ = ['ISylkApplication', 'ApplicationRegistry', 'SylkApplication', 'IncomingRequestHandler', 'ApplicationLogger']
import abc
import os
import socket
import struct
import sys
from collections import defaultdict
from application import log
from application.configuration.datatypes import NetworkRange
from application.notification import IObserver, NotificationCenter
from application.python import Null
from application.python.types import Singleton
from itertools import chain
from sipsimple.threading import run_in_twisted_thread
from zope.interface import implements
from sylk.configuration import ServerConfig, SIPConfig, ThorNodeConfig
SYLK_APP_HEADER = 'X-Sylk-App'
class ApplicationRegistry(object):
__metaclass__ = Singleton
def __init__(self):
self.applications = []
def __iter__(self):
return iter(self.applications)
def find_application(self, name):
try:
return next(app for app in self.applications if app.__appname__ == name)
except StopIteration:
return None
def add(self, app):
if app not in self.applications:
self.applications.append(app)
class ApplicationName(object):
def __get__(self, obj, objtype):
name = objtype.__name__
return name[:-11].lower() if name.endswith('Application') else name.lower()
class SylkApplicationMeta(abc.ABCMeta, Singleton):
"""Metaclass for defining SylkServer applications: a Singleton that also adds them to the application registry"""
def __init__(cls, name, bases, dic):
super(SylkApplicationMeta, cls).__init__(name, bases, dic)
if name != 'SylkApplication':
ApplicationRegistry().add(cls)
class SylkApplication(object):
"""Base class for all SylkServer applications"""
__metaclass__ = SylkApplicationMeta
__appname__ = ApplicationName()
@abc.abstractmethod
def start(self):
pass
@abc.abstractmethod
def stop(self):
pass
@abc.abstractmethod
def incoming_session(self, session):
pass
@abc.abstractmethod
def incoming_subscription(self, subscribe_request, data):
pass
@abc.abstractmethod
def incoming_referral(self, refer_request, data):
pass
@abc.abstractmethod
def incoming_message(self, message_request, data):
pass
def load_builtin_applications():
toplevel = os.path.dirname(__file__)
app_list = [item for item in os.listdir(toplevel) if os.path.isdir(os.path.join(toplevel, item)) and '__init__.py' in os.listdir(os.path.join(toplevel, item))]
for module in ['sylk.applications.%s' % item for item in set(app_list).difference(ServerConfig.disabled_applications)]:
try:
__import__(module)
except ImportError, e:
log.warning('Error loading builtin "%s" application: %s' % (module, e))
def load_extra_applications():
if ServerConfig.extra_applications_dir:
toplevel = os.path.realpath(os.path.abspath(ServerConfig.extra_applications_dir.normalized))
if os.path.isdir(toplevel):
app_list = [item for item in os.listdir(toplevel) if os.path.isdir(os.path.join(toplevel, item)) and '__init__.py' in os.listdir(os.path.join(toplevel, item))]
sys.path.append(toplevel)
for module in (item for item in set(app_list).difference(ServerConfig.disabled_applications)):
try:
__import__(module)
except ImportError, e:
log.warning('Error loading extra "%s" application: %s' % (module, e))
def load_applications():
load_builtin_applications()
load_extra_applications()
for app in ApplicationRegistry():
try:
app()
except Exception, e:
log.warning('Error loading application: %s' % e)
log.err()
class ApplicationNotLoadedError(Exception):
pass
class IncomingRequestHandler(object):
"""
Handle incoming requests and match them to applications.
"""
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
load_applications()
registry = ApplicationRegistry()
self.applications = dict((app.__appname__, app) for app in registry)
log.msg('Loaded applications: %s' % ', '.join(self.applications.keys()))
default_application = registry.find_application(ServerConfig.default_application)
if default_application is None:
log.warning('Default application "%s" does not exist, falling back to "conference"' % ServerConfig.default_application)
ServerConfig.default_application = 'conference'
else:
log.msg('Default application: %s' % ServerConfig.default_application)
self.application_map = dict((item.split(':')) for item in ServerConfig.application_map)
if self.application_map:
txt = 'Application map:\n'
invert_app_map = defaultdict(list)
for url, app in self.application_map.iteritems():
invert_app_map[app].append(url)
for app, urls in invert_app_map.iteritems():
txt += ' * %s:\n' % app
for url in urls:
txt += ' - %s\n' % url
log.msg(txt[:-1])
self.authorization_handler = AuthorizationHandler()
def start(self):
for app in ApplicationRegistry():
try:
app().start()
except Exception, e:
log.warning('Error starting application: %s' % e)
log.err()
self.authorization_handler.start()
notification_center = NotificationCenter()
notification_center.add_observer(self, name='SIPSessionNewIncoming')
notification_center.add_observer(self, name='SIPIncomingSubscriptionGotSubscribe')
notification_center.add_observer(self, name='SIPIncomingReferralGotRefer')
notification_center.add_observer(self, name='SIPIncomingRequestGotRequest')
def stop(self):
self.authorization_handler.stop()
notification_center = NotificationCenter()
notification_center.remove_observer(self, name='SIPSessionNewIncoming')
notification_center.remove_observer(self, name='SIPIncomingSubscriptionGotSubscribe')
notification_center.remove_observer(self, name='SIPIncomingReferralGotRefer')
notification_center.remove_observer(self, name='SIPIncomingRequestGotRequest')
for app in ApplicationRegistry():
try:
app().stop()
except Exception, e:
log.warning('Error stopping application: %s' % e)
log.err()
def get_application(self, ruri, headers):
if SYLK_APP_HEADER in headers:
application = headers[SYLK_APP_HEADER].body.strip()
else:
application = ServerConfig.default_application
if self.application_map:
prefixes = ("%s@%s" % (ruri.user, ruri.host), ruri.host, ruri.user)
for prefix in prefixes:
if prefix in self.application_map:
application = self.application_map[prefix]
break
try:
app = self.applications[application]
except KeyError:
log.error('Application %s is not loaded' % application)
raise ApplicationNotLoadedError
else:
return app()
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionNewIncoming(self, notification):
session = notification.sender
try:
self.authorization_handler.authorize_source(session.peer_address.ip)
except UnauthorizedRequest:
session.reject(403)
return
try:
app = self.get_application(session.request_uri, notification.data.headers)
except ApplicationNotLoadedError:
session.reject(404)
else:
app.incoming_session(session)
def _NH_SIPIncomingSubscriptionGotSubscribe(self, notification):
subscribe_request = notification.sender
try:
self.authorization_handler.authorize_source(subscribe_request.peer_address.ip)
except UnauthorizedRequest:
subscribe_request.reject(403)
return
try:
app = self.get_application(notification.data.request_uri, notification.data.headers)
except ApplicationNotLoadedError:
subscribe_request.reject(404)
else:
app.incoming_subscription(subscribe_request, notification.data)
def _NH_SIPIncomingReferralGotRefer(self, notification):
refer_request = notification.sender
try:
self.authorization_handler.authorize_source(refer_request.peer_address.ip)
except UnauthorizedRequest:
refer_request.reject(403)
return
try:
app = self.get_application(notification.data.request_uri, notification.data.headers)
except ApplicationNotLoadedError:
refer_request.reject(404)
else:
app.incoming_referral(refer_request, notification.data)
def _NH_SIPIncomingRequestGotRequest(self, notification):
request = notification.sender
if notification.data.method != 'MESSAGE':
request.answer(405)
return
try:
self.authorization_handler.authorize_source(request.peer_address.ip)
except UnauthorizedRequest:
request.answer(403)
return
try:
app = self.get_application(notification.data.request_uri, notification.data.headers)
except ApplicationNotLoadedError:
request.answer(404)
else:
app.incoming_message(request, notification.data)
class UnauthorizedRequest(Exception):
pass
class AuthorizationHandler(object):
implements(IObserver)
def __init__(self):
self.state = None
self.trusted_peers = SIPConfig.trusted_peers
self.thor_nodes = []
@property
def trusted_parties(self):
if ThorNodeConfig.enabled:
return self.thor_nodes
return self.trusted_peers
def start(self):
NotificationCenter().add_observer(self, name='ThorNetworkGotUpdate')
self.state = 'started'
def stop(self):
self.state = 'stopped'
NotificationCenter().remove_observer(self, name='ThorNetworkGotUpdate')
def authorize_source(self, ip_address):
if self.state != 'started':
raise UnauthorizedRequest
for range in self.trusted_parties:
if struct.unpack('!L', socket.inet_aton(ip_address))[0] & range[1] == range[0]:
return True
raise UnauthorizedRequest
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_ThorNetworkGotUpdate(self, notification):
thor_nodes = []
for node in chain(*(n.nodes for n in notification.data.networks.values())):
thor_nodes.append(NetworkRange(node))
self.thor_nodes = thor_nodes
class ApplicationLogger(object):
__metaclass__ = Singleton
@classmethod
def for_package(cls, package):
return cls(package.split('.')[-1])
def __init__(self, prefix):
self.prefix = '[%s] ' % prefix
def info(self, message, **context):
log.info(self.prefix+message, **context)
def warning(self, message, **context):
log.warning(self.prefix+message, **context)
def debug(self, message, **context):
log.debug(self.prefix+message, **context)
def error(self, message, **context):
log.error(self.prefix+message, **context)
def critical(self, message, **context):
log.critical(self.prefix+message, **context)
def exception(self, message=None, **context):
if message is not None:
message = self.prefix+message
log.exception(message, **context)
# Some aliases that are commonly used
msg = info
warn = warning
fatal = critical
err = exception
diff --git a/sylk/applications/conference/__init__.py b/sylk/applications/conference/__init__.py
index 6a2bf60..0c51f44 100644
--- a/sylk/applications/conference/__init__.py
+++ b/sylk/applications/conference/__init__.py
@@ -1,414 +1,412 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details
-#
import os
import re
import shutil
from application.notification import IObserver, NotificationCenter
from application.python import Null
from sipsimple.account.bonjour import BonjourPresenceState
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import SIPURI, SIPCoreError
from sipsimple.core import Header, FromHeader, ToHeader, SubjectHeader
from sipsimple.lookup import DNSLookup
from sipsimple.streams import MediaStreamRegistry
from sipsimple.threading.green import run_in_green_thread
from twisted.internet import reactor
from zope.interface import implements
from sylk.accounts import DefaultAccount
from sylk.applications import SylkApplication
from sylk.applications.conference.configuration import get_room_config, ConferenceConfig
from sylk.applications.conference.logger import log
from sylk.applications.conference.room import Room
from sylk.applications.conference.web import ConferenceWeb
from sylk.bonjour import BonjourService
from sylk.configuration import ServerConfig, ThorNodeConfig
from sylk.session import Session, IllegalStateError
from sylk.web import server as web_server
class ACLValidationError(Exception): pass
class RoomNotFoundError(Exception): pass
class ConferenceApplication(SylkApplication):
implements(IObserver)
def __init__(self):
self._rooms = {}
self.invited_participants_map = {}
self.bonjour_focus_service = Null
self.bonjour_room_service = Null
self.web = Null
def start(self):
self.web = ConferenceWeb(self)
web_server.register_resource('conference', self.web.resource())
# cleanup old files
for path in (ConferenceConfig.file_transfer_dir, ConferenceConfig.screensharing_images_dir):
try:
shutil.rmtree(path)
except EnvironmentError:
pass
if ServerConfig.enable_bonjour and ServerConfig.default_application == 'conference':
self.bonjour_focus_service = BonjourService(service='sipfocus')
self.bonjour_focus_service.start()
log.msg("Bonjour publication started for service 'sipfocus'")
self.bonjour_room_service = BonjourService(service='sipuri', name='Conference Room', uri_user='conference')
self.bonjour_room_service.start()
self.bonjour_room_service.presence_state = BonjourPresenceState('available', u'No participants')
log.msg("Bonjour publication started for service 'sipuri'")
def stop(self):
self.bonjour_focus_service.stop()
self.bonjour_room_service.stop()
def get_room(self, uri, create=False):
room_uri = '%s@%s' % (uri.user, uri.host)
try:
room = self._rooms[room_uri]
except KeyError:
if create:
room = Room(room_uri)
self._rooms[room_uri] = room
return room
else:
raise RoomNotFoundError
else:
return room
def remove_room(self, uri):
room_uri = '%s@%s' % (uri.user, uri.host)
self._rooms.pop(room_uri, None)
def validate_acl(self, room_uri, from_uri):
room_uri = '%s@%s' % (room_uri.user, room_uri.host)
cfg = get_room_config(room_uri)
if cfg.access_policy == 'allow,deny':
if cfg.allow.match(from_uri) and not cfg.deny.match(from_uri):
return
raise ACLValidationError
else:
if cfg.deny.match(from_uri) and not cfg.allow.match(from_uri):
raise ACLValidationError
def incoming_session(self, session):
log.msg('New session from %s to %s' % (session.remote_identity.uri, session.local_identity.uri))
audio_streams = [stream for stream in session.proposed_streams if stream.type=='audio']
chat_streams = [stream for stream in session.proposed_streams if stream.type=='chat']
transfer_streams = [stream for stream in session.proposed_streams if stream.type=='file-transfer']
if not audio_streams and not chat_streams and not transfer_streams:
log.msg(u'Session rejected: invalid media, only RTP audio and MSRP chat are supported')
session.reject(488)
return
audio_stream = audio_streams[0] if audio_streams else None
chat_stream = chat_streams[0] if chat_streams else None
transfer_stream = transfer_streams[0] if transfer_streams else None
try:
self.validate_acl(session.request_uri, session.remote_identity.uri)
except ACLValidationError:
log.msg(u'Session rejected: unauthorized by access list')
session.reject(403)
return
if transfer_stream is not None:
try:
room = self.get_room(session.request_uri)
except RoomNotFoundError:
log.msg(u'Session rejected: room not found')
session.reject(404)
return
if transfer_stream.direction == 'sendonly':
# file transfer 'pull'
try:
file = next(file for file in room.files if file.hash == transfer_stream.file_selector.hash)
except StopIteration:
log.msg(u'Session rejected: requested file not found')
session.reject(404)
return
try:
transfer_stream.file_selector = file.file_selector
except EnvironmentError, e:
log.msg(u'Session rejected: error opening requested file: %s' % e)
session.reject(404)
return
else:
transfer_stream.handler.save_directory = os.path.join(ConferenceConfig.file_transfer_dir.normalized, room.uri)
NotificationCenter().add_observer(self, sender=session)
if audio_stream:
session.send_ring_indication()
streams = [stream for stream in (audio_stream, chat_stream, transfer_stream) if stream]
reactor.callLater(4 if audio_stream is not None else 0, self.accept_session, session, streams)
def incoming_subscription(self, subscribe_request, data):
from_header = data.headers.get('From', Null)
to_header = data.headers.get('To', Null)
if Null in (from_header, to_header):
subscribe_request.reject(400)
return
if subscribe_request.event != 'conference':
log.msg(u'Subscription for event %s rejected: only conference event is supported' % subscribe_request.event)
subscribe_request.reject(489)
return
try:
self.validate_acl(data.request_uri, from_header.uri)
except ACLValidationError:
try:
self.validate_acl(to_header.uri, from_header.uri)
except ACLValidationError:
# Check if we need to skip the ACL because this was an invited participant
if not (str(from_header.uri) in self.invited_participants_map.get('%s@%s' % (data.request_uri.user, data.request_uri.host), {}) or
str(from_header.uri) in self.invited_participants_map.get('%s@%s' % (to_header.uri.user, to_header.uri.host), {})):
log.msg(u'Subscription rejected: unauthorized by access list')
subscribe_request.reject(403)
return
try:
room = self.get_room(data.request_uri)
except RoomNotFoundError:
try:
room = self.get_room(to_header.uri)
except RoomNotFoundError:
log.msg(u'Subscription rejected: room not yet created')
subscribe_request.reject(480)
return
if not room.started:
log.msg(u'Subscription rejected: room not started yet')
subscribe_request.reject(480)
else:
room.handle_incoming_subscription(subscribe_request, data)
def incoming_referral(self, refer_request, data):
from_header = data.headers.get('From', Null)
to_header = data.headers.get('To', Null)
refer_to_header = data.headers.get('Refer-To', Null)
if Null in (from_header, to_header, refer_to_header):
refer_request.reject(400)
return
log.msg(u'Room %s - join request from %s to %s' % ('%s@%s' % (to_header.uri.user, to_header.uri.host), from_header.uri, refer_to_header.uri))
try:
self.validate_acl(data.request_uri, from_header.uri)
except ACLValidationError:
log.msg(u'Room %s - invite participant request rejected: unauthorized by access list' % data.request_uri)
refer_request.reject(403)
return
referral_handler = IncomingReferralHandler(refer_request, data)
referral_handler.start()
def incoming_message(self, message_request, data):
log.msg(u'SIP MESSAGE is not supported, use MSRP media instead')
message_request.answer(405)
def accept_session(self, session, streams):
if session.state == 'incoming':
try:
session.accept(streams, is_focus=True)
except IllegalStateError:
pass
def add_participant(self, session, room_uri):
# Keep track of the invited participants, we must skip ACL policy
# for SUBSCRIBE requests
room_uri_str = '%s@%s' % (room_uri.user, room_uri.host)
log.msg(u'Room %s - outgoing session to %s started' % (room_uri_str, session.remote_identity.uri))
d = self.invited_participants_map.setdefault(room_uri_str, {})
d.setdefault(str(session.remote_identity.uri), 0)
d[str(session.remote_identity.uri)] += 1
NotificationCenter().add_observer(self, sender=session)
room = self.get_room(room_uri, True)
room.start()
room.add_session(session)
def remove_participant(self, participant_uri, room_uri):
try:
room = self.get_room(room_uri)
except RoomNotFoundError:
pass
else:
log.msg('Room %s - %s removed from conference' % (room_uri, participant_uri))
room.terminate_sessions(participant_uri)
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionDidStart(self, notification):
session = notification.sender
room = self.get_room(session.request_uri, True)
room.start()
room.add_session(session)
@run_in_green_thread
def _NH_SIPSessionDidEnd(self, notification):
session = notification.sender
notification.center.remove_observer(self, sender=session)
if session.direction == 'incoming':
room_uri = session.request_uri
else:
# Clear invited participants mapping
room_uri_str = '%s@%s' % (session.local_identity.uri.user, session.local_identity.uri.host)
d = self.invited_participants_map[room_uri_str]
d[str(session.remote_identity.uri)] -= 1
if d[str(session.remote_identity.uri)] == 0:
del d[str(session.remote_identity.uri)]
room_uri = session.local_identity.uri
# We could get this notifiction even if we didn't get SIPSessionDidStart
try:
room = self.get_room(room_uri)
except RoomNotFoundError:
return
if session in room.sessions:
room.remove_session(session)
if not room.stopping and room.empty:
self.remove_room(room_uri)
room.stop()
def _NH_SIPSessionDidFail(self, notification):
session = notification.sender
notification.center.remove_observer(self, sender=session)
log.msg(u'Session from %s failed: %s' % (session.remote_identity.uri, notification.data.reason))
class IncomingReferralHandler(object):
implements(IObserver)
def __init__(self, refer_request, data):
self._refer_request = refer_request
self._refer_headers = data.headers
self.room_uri = data.request_uri
self.room_uri_str = '%s@%s' % (self.room_uri.user, self.room_uri.host)
self.refer_to_uri = re.sub('<|>', '', data.headers.get('Refer-To').uri)
self.method = data.headers.get('Refer-To').parameters.get('method', 'INVITE').upper()
self.session = None
self.streams = []
def start(self):
if not self.refer_to_uri.startswith(('sip:', 'sips:')):
self.refer_to_uri = 'sip:%s' % self.refer_to_uri
try:
self.refer_to_uri = SIPURI.parse(self.refer_to_uri)
except SIPCoreError:
log.msg('Room %s - failed to add %s' % (self.room_uri_str, self.refer_to_uri))
self._refer_request.reject(488)
return
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self._refer_request)
if self.method == 'INVITE':
self._refer_request.accept()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = self.refer_to_uri
lookup = DNSLookup()
notification_center.add_observer(self, sender=lookup)
lookup.lookup_sip_proxy(uri, settings.sip.transport_list)
elif self.method == 'BYE':
log.msg('Room %s - %s removed %s from the room' % (self.room_uri_str, self._refer_headers.get('From').uri, self.refer_to_uri))
self._refer_request.accept()
conference_application = ConferenceApplication()
conference_application.remove_participant(self.refer_to_uri, self.room_uri)
self._refer_request.end(200)
else:
self._refer_request.reject(488)
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_DNSLookupDidSucceed(self, notification):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=notification.sender)
account = DefaultAccount()
conference_application = ConferenceApplication()
try:
room = conference_application.get_room(self.room_uri)
except RoomNotFoundError:
log.msg('Room %s - failed to add %s' % (self.room_uri_str, self.refer_to_uri))
self._refer_request.end(500)
return
active_media = set(room.active_media).intersection(('audio', 'chat'))
if not active_media:
log.msg('Room %s - failed to add %s' % (self.room_uri_str, self.refer_to_uri))
self._refer_request.end(500)
return
registry = MediaStreamRegistry()
for stream_type in active_media:
self.streams.append(registry.get(stream_type)())
self.session = Session(account)
notification_center.add_observer(self, sender=self.session)
original_from_header = self._refer_headers.get('From')
if original_from_header.display_name:
original_identity = "%s <%s@%s>" % (original_from_header.display_name, original_from_header.uri.user, original_from_header.uri.host)
else:
original_identity = "%s@%s" % (original_from_header.uri.user, original_from_header.uri.host)
from_header = FromHeader(SIPURI.new(self.room_uri), u'Conference Call')
to_header = ToHeader(self.refer_to_uri)
extra_headers = []
if self._refer_headers.get('Referred-By', None) is not None:
extra_headers.append(Header.new(self._refer_headers.get('Referred-By')))
else:
extra_headers.append(Header('Referred-By', str(original_from_header.uri)))
if ThorNodeConfig.enabled:
extra_headers.append(Header('Thor-Scope', 'conference-invitation'))
extra_headers.append(Header('X-Originator-From', str(original_from_header.uri)))
extra_headers.append(SubjectHeader(u'Join conference request from %s' % original_identity))
route = notification.data.result[0]
self.session.connect(from_header, to_header, route=route, streams=self.streams, is_focus=True, extra_headers=extra_headers)
def _NH_DNSLookupDidFail(self, notification):
notification.center.remove_observer(self, sender=notification.sender)
def _NH_SIPSessionGotRingIndication(self, notification):
if self._refer_request is not None:
self._refer_request.send_notify(180)
def _NH_SIPSessionGotProvisionalResponse(self, notification):
if self._refer_request is not None:
self._refer_request.send_notify(notification.data.code, notification.data.reason)
def _NH_SIPSessionDidStart(self, notification):
notification.center.remove_observer(self, sender=notification.sender)
if self._refer_request is not None:
self._refer_request.end(200)
conference_application = ConferenceApplication()
conference_application.add_participant(self.session, self.room_uri)
log.msg('Room %s - %s added %s' % (self.room_uri_str, self._refer_headers.get('From').uri, self.refer_to_uri))
self.session = None
self.streams = []
def _NH_SIPSessionDidFail(self, notification):
log.msg('Room %s - failed to add %s: %s' % (self.room_uri_str, self.refer_to_uri, notification.data.reason))
notification.center.remove_observer(self, sender=notification.sender)
if self._refer_request is not None:
self._refer_request.end(notification.data.code or 500, notification.data.reason or notification.data.code)
self.session = None
self.streams = []
def _NH_SIPSessionDidEnd(self, notification):
# If any stream fails to start we won't get SIPSessionDidFail, we'll get here instead
log.msg('Room %s - failed to add %s' % (self.room_uri_str, self.refer_to_uri))
notification.center.remove_observer(self, sender=notification.sender)
if self._refer_request is not None:
self._refer_request.end(200)
self.session = None
self.streams = []
def _NH_SIPIncomingReferralDidEnd(self, notification):
notification.center.remove_observer(self, sender=notification.sender)
self._refer_request = None
diff --git a/sylk/applications/conference/configuration.py b/sylk/applications/conference/configuration.py
index f39b068..f467c86 100644
--- a/sylk/applications/conference/configuration.py
+++ b/sylk/applications/conference/configuration.py
@@ -1,133 +1,131 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
__all__ = ['ConferenceConfig', 'get_room_config']
import os
import re
from application.configuration import ConfigFile, ConfigSection, ConfigSetting
from application.configuration.datatypes import StringList
from sylk.configuration import ServerConfig
from sylk.configuration.datatypes import Path, URL
# Datatypes
class AccessPolicyValue(str):
allowed_values = ('allow,deny', 'deny,allow')
def __new__(cls, value):
value = re.sub('\s', '', value)
if value not in cls.allowed_values:
raise ValueError('invalid value, allowed values are: %s' % ' | '.join(cls.allowed_values))
return str.__new__(cls, value)
class Domain(str):
domain_re = re.compile(r"^[a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*$")
def __new__(cls, value):
value = str(value)
if not cls.domain_re.match(value):
raise ValueError("illegal domain: %s" % value)
return str.__new__(cls, value)
class SIPAddress(str):
def __new__(cls, address):
address = str(address)
address = address.replace('@', '%40', address.count('@')-1)
try:
username, domain = address.split('@')
Domain(domain)
except ValueError:
raise ValueError("illegal SIP address: %s, must be in user@domain format" % address)
return str.__new__(cls, address)
class PolicySettingValue(list):
def __init__(self, value):
if isinstance(value, (tuple, list)):
l = [str(x) for x in value]
elif isinstance(value, basestring):
if value.lower() in ('none', ''):
return list.__init__(self, [])
elif value.lower() in ('any', 'all', '*'):
return list.__init__(self, ['*'])
else:
l = re.split(r'\s*,\s*', value)
else:
raise TypeError("value must be a string, list or tuple")
values = []
for item in l:
if '@' in item:
values.append(SIPAddress(item))
else:
values.append(Domain(item))
return list.__init__(self, values)
def match(self, uri):
if self == ['*']:
return True
domain = uri.host
uri = re.sub('^(sip:|sips:)', '', str(uri))
return uri in self or domain in self
# Configuration objects
class ConferenceConfig(ConfigSection):
__cfgfile__ = 'conference.ini'
__section__ = 'Conference'
history_size = 20
access_policy = ConfigSetting(type=AccessPolicyValue, value=AccessPolicyValue('allow, deny'))
allow = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('all'))
deny = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('none'))
file_transfer_dir = ConfigSetting(type=Path, value=Path(os.path.join(ServerConfig.spool_dir.normalized, 'conference', 'files')))
push_file_transfer = False
screensharing_images_dir = ConfigSetting(type=Path, value=Path(os.path.join(ServerConfig.spool_dir.normalized, 'conference', 'screensharing')))
advertise_xmpp_support = True
pstn_access_numbers = ConfigSetting(type=StringList, value='')
webrtc_gateway_url = ConfigSetting(type=URL, value='')
zrtp_auto_verify = True
class RoomConfig(ConfigSection):
__cfgfile__ = 'conference.ini'
access_policy = ConfigSetting(type=AccessPolicyValue, value=AccessPolicyValue('allow, deny'))
allow = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('all'))
deny = ConfigSetting(type=PolicySettingValue, value=PolicySettingValue('none'))
pstn_access_numbers = ConfigSetting(type=StringList, value=ConferenceConfig.pstn_access_numbers)
advertise_xmpp_support = ConferenceConfig.advertise_xmpp_support
webrtc_gateway_url = ConferenceConfig.webrtc_gateway_url
zrtp_auto_verify = ConferenceConfig.zrtp_auto_verify
class Configuration(object):
def __init__(self, data):
self.__dict__.update(data)
def get_room_config(room):
config_file = ConfigFile(RoomConfig.__cfgfile__)
section = config_file.get_section(room)
if section is not None:
RoomConfig.read(section=room)
config = Configuration(dict(RoomConfig))
RoomConfig.reset()
else:
# Apply general policy
config = Configuration(dict(RoomConfig))
return config
diff --git a/sylk/applications/conference/logger.py b/sylk/applications/conference/logger.py
index 1fc09c6..e2405c7 100644
--- a/sylk/applications/conference/logger.py
+++ b/sylk/applications/conference/logger.py
@@ -1,9 +1,7 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
__all__ = ['log']
from sylk.applications import ApplicationLogger
log = ApplicationLogger.for_package(__package__)
diff --git a/sylk/applications/conference/room.py b/sylk/applications/conference/room.py
index ef8c72a..5bf0aa2 100644
--- a/sylk/applications/conference/room.py
+++ b/sylk/applications/conference/room.py
@@ -1,1077 +1,1075 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
import os
import random
import shutil
import string
import weakref
from collections import defaultdict, deque
from glob import glob
from itertools import chain, count, cycle
from application.notification import IObserver, NotificationCenter
from application.python import Null
from application.system import makedirs
from eventlib import api, coros, proc
from sipsimple.account.bonjour import BonjourPresenceState
from sipsimple.application import SIPApplication
from sipsimple.audio import AudioConference, WavePlayer, WavePlayerError
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import SIPCoreError, SIPCoreInvalidStateError, SIPURI
from sipsimple.core import Header, FromHeader, ToHeader, SubjectHeader
from sipsimple.lookup import DNSLookup, DNSLookupError
from sipsimple.payloads import conference
from sipsimple.streams import MediaStreamRegistry
from sipsimple.streams.msrp.chat import ChatIdentity, CPIMHeader, CPIMNamespace
from sipsimple.streams.msrp.filetransfer import FileSelector
from sipsimple.threading import run_in_thread, run_in_twisted_thread
from sipsimple.threading.green import run_in_green_thread
from sipsimple.util import ISOTimestamp
from twisted.internet import reactor
from zope.interface import implements
from sylk.accounts import DefaultAccount
from sylk.applications.conference.configuration import get_room_config, ConferenceConfig
from sylk.applications.conference.logger import log
from sylk.bonjour import BonjourService
from sylk.configuration import ServerConfig, ThorNodeConfig
from sylk.configuration.datatypes import URL
from sylk.resources import Resources
from sylk.session import Session, IllegalStateError
from sylk.web import server as web_server
def format_identity(identity):
uri = identity.uri
if identity.display_name:
return u'%s <%s@%s>' % (identity.display_name, uri.user, uri.host)
else:
return u'%s@%s' % (uri.user, uri.host)
class ScreenImage(object):
def __init__(self, room, sender):
self.room = weakref.ref(room)
self.room_uri = room.uri
self.sender = sender
self.filename = os.path.join(ConferenceConfig.screensharing_images_dir, room.uri, '%s@%s_%s.jpg' % (sender.uri.user, sender.uri.host, ''.join(random.sample(string.letters+string.digits, 10))))
self.url = URL(web_server.url + '/conference/' + room.uri + '/screensharing')
self.url.query_items['image'] = os.path.basename(self.filename)
self.state = None
self.timer = None
@property
def active(self):
return self.state == 'active'
@property
def idle(self):
return self.state == 'idle'
@run_in_thread('file-io')
def save(self, image):
makedirs(os.path.dirname(self.filename))
tmp_filename = self.filename + '.tmp'
try:
with open(tmp_filename, 'wb') as file:
file.write(image)
except EnvironmentError, e:
log.msg('Room %s - cannot write screen sharing image: %s: %s' % (self.room_uri, self.filename, e))
else:
try:
os.rename(tmp_filename, self.filename)
except EnvironmentError:
pass
self.advertise()
@run_in_twisted_thread
def advertise(self):
if self.state == 'active':
self.timer.reset(10)
else:
if self.timer is not None and self.timer.active():
self.timer.cancel()
self.state = 'active'
self.timer = reactor.callLater(10, self.stop_advertising)
room = self.room() or Null
room.dispatch_conference_info()
txt = 'Room %s - %s is sharing the screen at %s' % (self.room_uri, format_identity(self.sender), self.url)
room.dispatch_server_message(txt)
log.msg(txt)
@run_in_twisted_thread
def stop_advertising(self):
if self.state != 'idle':
if self.timer is not None and self.timer.active():
self.timer.cancel()
self.state = 'idle'
self.timer = None
room = self.room() or Null
room.dispatch_conference_info()
txt = '%s stopped sharing the screen' % format_identity(self.sender)
room.dispatch_server_message(txt)
log.msg(txt)
class Room(object):
"""
Object representing a conference room, it will handle the message dispatching
among all the participants.
"""
implements(IObserver)
def __init__(self, uri):
self.config = get_room_config(uri)
self.uri = uri
self.identity = ChatIdentity(SIPURI.parse('sip:%s' % self.uri), display_name='Conference Room')
self.files = []
self.screen_images = {}
self.sessions = []
self.subscriptions = []
self.state = 'stopped'
self.incoming_message_queue = coros.queue()
self.message_dispatcher = None
self.audio_conference = None
self.moh_player = None
self.conference_info_payload = None
self.conference_info_version = count(1)
self.bonjour_services = Null
self.session_nickname_map = {}
self.last_nicknames_map = {}
self.participants_counter = defaultdict(lambda: 0)
self.history = deque(maxlen=ConferenceConfig.history_size)
@property
def empty(self):
return len(self.sessions) == 0
@property
def started(self):
return self.state == 'started'
@property
def stopping(self):
return self.state in ('stopping', 'stopped')
@property
def active_media(self):
return set((stream.type for stream in chain(*(session.streams for session in self.sessions if session.streams))))
@property
def conference_info(self):
if self.conference_info_payload is None:
settings = SIPSimpleSettings()
conference_description = conference.ConferenceDescription(display_text='Ad-hoc conference', free_text='Hosted by %s' % settings.user_agent)
conference_description.conf_uris = conference.ConfUris()
conference_description.conf_uris.add(conference.ConfUrisEntry('sip:%s' % self.uri, purpose='participation'))
if self.config.advertise_xmpp_support:
conference_description.conf_uris.add(conference.ConfUrisEntry('xmpp:%s' % self.uri, purpose='participation'))
# TODO: add grouptextchat service uri
for number in self.config.pstn_access_numbers:
conference_description.conf_uris.add(conference.ConfUrisEntry('tel:%s' % number, purpose='participation'))
host_info = conference.HostInfo(web_page=conference.WebPage('http://sylkserver.com'))
self.conference_info_payload = conference.Conference(self.identity.uri, conference_description=conference_description, host_info=host_info, users=conference.Users())
self.conference_info_payload.version = next(self.conference_info_version)
user_count = len(self.participants_counter.keys())
self.conference_info_payload.conference_state = conference.ConferenceState(user_count=user_count, active=True)
users = conference.Users()
for session in (session for session in self.sessions if not (len(session.streams) == 1 and session.streams[0].type == 'file-transfer')):
try:
user = next(user for user in users if user.entity == str(session.remote_identity.uri))
except StopIteration:
display_text = self.last_nicknames_map.get(str(session.remote_identity.uri), session.remote_identity.display_name)
user = conference.User(str(session.remote_identity.uri), display_text=display_text)
user_uri = '%s@%s' % (session.remote_identity.uri.user, session.remote_identity.uri.host)
screen_image = self.screen_images.get(user_uri, None)
if screen_image is not None and screen_image.active:
user.screen_image_url = screen_image.url
users.add(user)
joining_info = conference.JoiningInfo(when=session.start_time)
holdable_streams = [stream for stream in session.streams if stream.hold_supported]
session_on_hold = holdable_streams and all(stream.on_hold_by_remote for stream in holdable_streams)
hold_status = conference.EndpointStatus('on-hold' if session_on_hold else 'connected')
display_text = self.session_nickname_map.get(session, session.remote_identity.display_name)
endpoint = conference.Endpoint(str(session._invitation.remote_contact_header.uri), display_text=display_text, joining_info=joining_info, status=hold_status)
for stream in session.streams:
if stream.type == 'file-transfer':
continue
endpoint.add(conference.Media(id(stream), media_type=self.format_conference_stream_type(stream)))
user.add(endpoint)
self.conference_info_payload.users = users
if self.files:
files = conference.FileResources(conference.FileResource(os.path.basename(file.name), file.hash, file.size, file.sender, 'OK') for file in self.files)
self.conference_info_payload.conference_description.resources = conference.Resources(files=files)
return self.conference_info_payload.toxml()
def start(self):
if self.started:
return
if ServerConfig.enable_bonjour and self.identity.uri.user != 'conference':
room_user = self.identity.uri.user
self.bonjour_services = BonjourService(service='sipuri', name='Conference Room %s' % room_user, uri_user=room_user)
self.bonjour_services.start()
self.message_dispatcher = proc.spawn(self._message_dispatcher)
self.audio_conference = AudioConference()
self.audio_conference.hold()
self.moh_player = MoHPlayer(self.audio_conference)
self.moh_player.start()
self.state = 'started'
def stop(self):
if not self.started:
return
self.state = 'stopping'
self.bonjour_services.stop()
self.bonjour_services = None
self.incoming_message_queue.send_exception(api.GreenletExit)
self.incoming_message_queue = None
self.message_dispatcher.kill(proc.ProcExit)
self.message_dispatcher = None
self.moh_player.stop()
self.moh_player = None
self.audio_conference = None
notification_center = NotificationCenter()
for subscription in self.subscriptions:
notification_center.remove_observer(self, sender=subscription)
subscription.end()
self.subscriptions = []
self.cleanup_files()
self.conference_info_payload = None
self.state = 'stopped'
@run_in_thread('file-io')
def cleanup_files(self):
path = os.path.join(ConferenceConfig.file_transfer_dir, self.uri)
try:
shutil.rmtree(path)
except EnvironmentError:
pass
path = os.path.join(ConferenceConfig.screensharing_images_dir, self.uri)
try:
shutil.rmtree(path)
except EnvironmentError:
pass
def _message_dispatcher(self):
"""Read from self.incoming_message_queue and dispatch the messages to other participants"""
while True:
session, message_type, data = self.incoming_message_queue.wait()
if message_type == 'message':
message = data.message
if message.sender.uri != session.remote_identity.uri:
continue
if message.content.startswith('?OTR:'):
continue
if message.timestamp is None:
message.timestamp = ISOTimestamp.utcnow()
message.sender.display_name = self.last_nicknames_map.get(str(session.remote_identity.uri), message.sender.display_name)
recipient = message.recipients[0]
private = len(message.recipients) == 1 and '%s@%s' % (recipient.uri.user, recipient.uri.host) != self.uri
if private:
self.dispatch_private_message(session, message)
else:
self.history.append(message)
self.dispatch_message(session, message)
elif message_type == 'composing_indication':
if data.sender.uri != session.remote_identity.uri:
continue
recipient = data.recipients[0]
private = len(data.recipients) == 1 and '%s@%s' % (recipient.uri.user, recipient.uri.host) != self.uri
if private:
self.dispatch_private_iscomposing(session, data)
else:
self.dispatch_iscomposing(session, data)
def dispatch_message(self, session, message):
for s in (s for s in self.sessions if s is not session):
try:
chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
except StopIteration:
continue
chat_stream.send_message(message.content, message.content_type, sender=message.sender, recipients=[self.identity], timestamp=message.timestamp, additional_headers=message.additional_headers)
def dispatch_private_message(self, session, message):
# Private messages are delivered to all sessions matching the recipient but also to the sender,
# for replication in clients
recipient = message.recipients[0]
for s in (s for s in self.sessions if s is not session and s.remote_identity.uri in (recipient.uri, session.remote_identity.uri)):
try:
chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
except StopIteration:
continue
chat_stream.send_message(message.content, message.content_type, sender=message.sender, recipients=[recipient], timestamp=message.timestamp, additional_headers=message.additional_headers)
def dispatch_iscomposing(self, session, data):
identity = ChatIdentity(session.remote_identity.uri, session.remote_identity.display_name)
for s in (s for s in self.sessions if s is not session):
try:
chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
except StopIteration:
continue
chat_stream.send_composing_indication(data.state, data.refresh, sender=identity, recipients=[self.identity])
def dispatch_private_iscomposing(self, session, data):
identity = ChatIdentity(session.remote_identity.uri, session.remote_identity.display_name)
recipient_uri = data.recipients[0].uri
for s in (s for s in self.sessions if s is not session and s.remote_identity.uri == recipient_uri):
try:
chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
except StopIteration:
continue
chat_stream.send_composing_indication(data.state, data.refresh, sender=identity)
def dispatch_server_message(self, content, content_type='text/plain', exclude=None):
ns = CPIMNamespace('urn:ag-projects:xml:ns:cpim', prefix='agp')
message_type = CPIMHeader('Message-Type', ns, 'status')
for session in (session for session in self.sessions if session is not exclude):
try:
chat_stream = next(stream for stream in session.streams if stream.type == 'chat')
except StopIteration:
continue
chat_stream.send_message(content, content_type, sender=self.identity, recipients=[self.identity], additional_headers=[message_type])
def dispatch_conference_info(self):
data = self.conference_info
for subscription in (subscription for subscription in self.subscriptions if subscription.state == 'active'):
try:
subscription.push_content(conference.ConferenceDocument.content_type, data)
except (SIPCoreError, SIPCoreInvalidStateError):
pass
def dispatch_file(self, file):
sender_uri = file.sender.uri
for uri in set(session.remote_identity.uri for session in self.sessions if str(session.remote_identity.uri) != str(sender_uri)):
handler = FileTransferHandler(self)
handler.init_outgoing(uri, file)
def add_session(self, session):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=session)
self.sessions.append(session)
remote_uri = str(session.remote_identity.uri)
self.participants_counter[remote_uri] += 1
try:
chat_stream = next(stream for stream in session.streams if stream.type == 'chat')
except StopIteration:
pass
else:
notification_center.add_observer(self, sender=chat_stream)
try:
audio_stream = next(stream for stream in session.streams if stream.type == 'audio')
except StopIteration:
pass
else:
notification_center.add_observer(self, sender=audio_stream)
log.msg(u'Room %s - audio stream %s/%sHz, end-points: %s:%d <-> %s:%d' % (self.uri, audio_stream.codec, audio_stream.sample_rate,
audio_stream.local_rtp_address, audio_stream.local_rtp_port,
audio_stream.remote_rtp_address, audio_stream.remote_rtp_port))
if audio_stream.encryption.type != 'ZRTP':
# We don't listen for stream notifications early enough
if audio_stream.encryption.active:
log.msg(u'Room %s - %s audio stream enabled %s encryption' % (self.uri,
format_identity(session.remote_identity),
audio_stream.encryption.type))
else:
log.msg(u'Room %s - %s audio stream did not enable encryption' % (self.uri,
format_identity(session.remote_identity)))
try:
transfer_stream = next(stream for stream in session.streams if stream.type == 'file-transfer')
except StopIteration:
pass
else:
transfer_handler = FileTransferHandler(self)
transfer_handler.init_incoming(transfer_stream)
if transfer_stream.direction == 'recvonly':
filename = os.path.basename(os.path.splitext(transfer_stream.file_selector.name)[0])
txt = u'Room %s - %s is uploading file %s (%s)' % (self.uri, format_identity(session.remote_identity), filename,self.format_file_size(transfer_stream.file_selector.size))
else:
filename = os.path.basename(transfer_stream.file_selector.name)
txt = u'Room %s - %s requested file %s' % (self.uri, format_identity(session.remote_identity), filename)
log.msg(txt)
self.dispatch_server_message(txt)
if len(session.streams) == 1:
return
welcome_handler = WelcomeHandler(self, initial=True, session=session, streams=session.streams)
welcome_handler.run()
self.dispatch_conference_info()
if len(self.sessions) == 1:
log.msg(u'Room %s - started by %s with %s' % (self.uri, format_identity(session.remote_identity), self.format_stream_types(session.streams)))
else:
log.msg(u'Room %s - %s joined with %s' % (self.uri, format_identity(session.remote_identity), self.format_stream_types(session.streams)))
if str(session.remote_identity.uri) not in set(str(s.remote_identity.uri) for s in self.sessions if s is not session):
self.dispatch_server_message('%s has joined the room %s' % (format_identity(session.remote_identity), self.format_stream_types(session.streams)), exclude=session)
if ServerConfig.enable_bonjour:
self._update_bonjour_presence()
def remove_session(self, session):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=session)
self.sessions.remove(session)
self.session_nickname_map.pop(session, None)
remote_uri = str(session.remote_identity.uri)
self.participants_counter[remote_uri] -= 1
if self.participants_counter[remote_uri] <= 0:
del self.participants_counter[remote_uri]
self.last_nicknames_map.pop(remote_uri, None)
try:
chat_stream = next(stream for stream in session.streams or [] if stream.type == 'chat')
except StopIteration:
pass
else:
notification_center.remove_observer(self, sender=chat_stream)
try:
audio_stream = next(stream for stream in session.streams or [] if stream.type == 'audio')
except StopIteration:
pass
else:
notification_center.remove_observer(self, sender=audio_stream)
try:
self.audio_conference.remove(audio_stream)
except ValueError:
# User may hangup before getting bridged into the conference
pass
if len(self.audio_conference.streams) == 0:
self.moh_player.pause()
self.audio_conference.hold()
elif len(self.audio_conference.streams) == 1:
self.moh_player.play()
try:
next(stream for stream in session.streams if stream.type == 'file-transfer')
except StopIteration:
pass
else:
if len(session.streams) == 1:
return
self.dispatch_conference_info()
log.msg(u'Room %s - %s left conference after %s' % (self.uri, format_identity(session.remote_identity), self.format_session_duration(session)))
if not self.sessions:
log.msg(u'Room %s - Last participant left conference' % self.uri)
if str(session.remote_identity.uri) not in set(str(s.remote_identity.uri) for s in self.sessions if s is not session):
self.dispatch_server_message('%s has left the room after %s' % (format_identity(session.remote_identity), self.format_session_duration(session)))
if ServerConfig.enable_bonjour:
self._update_bonjour_presence()
def terminate_sessions(self, uri):
if not self.started:
return
for session in (session for session in self.sessions if session.remote_identity.uri == uri):
session.end()
def handle_incoming_subscription(self, subscribe_request, data):
log.msg('Room %s - subscription from %s' % (self.uri, data.headers['From'].uri))
if subscribe_request.event != 'conference':
log.msg('Room %s - Subscription for event %s rejected: only conference event is supported' % (self.uri, subscribe_request.event))
subscribe_request.reject(489)
return
NotificationCenter().add_observer(self, sender=subscribe_request)
self.subscriptions.append(subscribe_request)
subscribe_request.accept(conference.ConferenceDocument.content_type, self.conference_info)
def _accept_proposal(self, session, streams):
try:
session.accept_proposal(streams)
except IllegalStateError:
pass
session.proposal_timer = None
def add_file(self, file):
self.dispatch_server_message('%s has uploaded file %s (%s)' % (format_identity(file.sender), os.path.basename(file.name), self.format_file_size(file.size)))
self.files.append(file)
self.dispatch_conference_info()
if ConferenceConfig.push_file_transfer:
self.dispatch_file(file)
def add_screen_image(self, sender, image):
sender_uri = '%s@%s' % (sender.uri.user, sender.uri.host)
screen_image = self.screen_images.setdefault(sender_uri, ScreenImage(self, sender))
screen_image.save(image)
def _update_bonjour_presence(self):
num = len(self.sessions)
if num == 0:
num_str = 'No'
elif num == 1:
num_str = 'One'
elif num == 2:
num_str = 'Two'
else:
num_str = str(num)
txt = u'%s participant%s' % (num_str, '' if num==1 else 's')
presence_state = BonjourPresenceState('available', txt)
if self.bonjour_services is Null:
# This is the room being published all the time
from sylk.applications.conference import ConferenceApplication
ConferenceApplication().bonjour_room_service.presence_state = presence_state
else:
self.bonjour_services.presence_state = presence_state
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_RTPStreamDidEnableEncryption(self, notification):
stream = notification.sender
session = stream.session
log.msg(u'Room %s - %s %s stream enabled %s encryption' % (self.uri,
format_identity(session.remote_identity),
stream.type,
stream.encryption.type))
def _NH_RTPStreamDidNotEnableEncryption(self, notification):
stream = notification.sender
session = stream.session
log.msg(u'Room %s - %s %s stream did not enable encryption: %s' % (self.uri,
format_identity(session.remote_identity),
stream.type,
notification.data.reason))
def _NH_RTPStreamZRTPReceivedSAS(self, notification):
if not self.config.zrtp_auto_verify:
return
stream = notification.sender
session = stream.session
sas = notification.data.sas
# Send ZRTP SAS over the chat stream, if available
try:
chat_stream = next(stream for stream in session.streams if stream.type=='chat')
except StopIteration:
return
# Only send the message if there are no relays in between
secure_chat = chat_stream.transport == 'tls' and all(len(path)==1 for path in (chat_stream.msrp.full_local_path, chat_stream.msrp.full_remote_path))
if secure_chat:
txt = 'Received ZRTP Short Authentication String: %s' % sas
# Don't set the remote identity, that way it will appear as a private message
ns = CPIMNamespace('urn:ag-projects:xml:ns:cpim', prefix='agp')
message_type = CPIMHeader('Message-Type', ns, 'status')
chat_stream.send_message(txt, 'text/plain', sender=self.identity, additional_headers=[message_type])
def _NH_RTPStreamDidTimeout(self, notification):
stream = notification.sender
if stream.type != 'audio':
return
session = stream.session
log.msg(u'Room %s - audio stream for session %s timed out' % (self.uri, format_identity(session.remote_identity)))
if session.streams == [stream]:
session.end()
def _NH_ChatStreamGotMessage(self, notification):
stream = notification.sender
data = notification.data
session = notification.sender.session
message = data.message
content_type = message.content_type.lower()
if content_type.startswith(('text/', 'image/')):
stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
self.incoming_message_queue.send((session, 'message', data))
elif content_type == 'application/blink-screensharing':
stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
self.add_screen_image(message.sender, message.content)
elif content_type == 'application/blink-zrtp-sas':
if not self.config.zrtp_auto_verify:
stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
return
try:
audio_stream = next(stream for stream in session.streams if stream.type=='audio' and stream.encryption.active and stream.encryption.type=='ZRTP')
except StopIteration:
stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
return
# Only trust it if there was a direct path and the transport is TLS
secure_chat = stream.transport == 'tls' and all(len(path)==1 for path in (stream.msrp.full_local_path, stream.msrp.full_remote_path))
remote_sas = str(message.content)
if remote_sas == audio_stream.encryption.zrtp.sas and secure_chat:
audio_stream.encryption.zrtp.verified = True
stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
else:
stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
else:
stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
def _NH_ChatStreamGotComposingIndication(self, notification):
stream = notification.sender
stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
data = notification.data
session = notification.sender.session
self.incoming_message_queue.send((session, 'composing_indication', data))
def _NH_ChatStreamGotNicknameRequest(self, notification):
nickname = notification.data.nickname
session = notification.sender.session
chunk = notification.data.chunk
if nickname:
if nickname in self.session_nickname_map.values() and (session not in self.session_nickname_map or self.session_nickname_map[session] != nickname):
notification.sender.reject_nickname(chunk, 425, 'Nickname reserved or already in use')
return
self.session_nickname_map[session] = nickname
self.last_nicknames_map[str(session.remote_identity.uri)] = nickname
else:
self.session_nickname_map.pop(session, None)
self.last_nicknames_map.pop(str(session.remote_identity.uri), None)
notification.sender.accept_nickname(chunk)
self.dispatch_conference_info()
def _NH_SIPIncomingSubscriptionDidEnd(self, notification):
subscription = notification.sender
try:
self.subscriptions.remove(subscription)
except ValueError:
pass
else:
notification.center.remove_observer(self, sender=subscription)
def _NH_SIPSessionDidChangeHoldState(self, notification):
session = notification.sender
if notification.data.originator == 'remote':
if notification.data.on_hold:
log.msg(u'Room %s - %s has put the audio session on hold' % (self.uri, format_identity(session.remote_identity)))
else:
log.msg(u'Room %s - %s has taken the audio session out of hold' % (self.uri, format_identity(session.remote_identity)))
self.dispatch_conference_info()
def _NH_SIPSessionNewProposal(self, notification):
if notification.data.originator == 'remote':
session = notification.sender
audio_streams = [stream for stream in notification.data.proposed_streams if stream.type=='audio']
chat_streams = [stream for stream in notification.data.proposed_streams if stream.type=='chat']
if not audio_streams and not chat_streams:
session.reject_proposal()
return
streams = [streams[0] for streams in (audio_streams, chat_streams) if streams]
timer = reactor.callLater(3, self._accept_proposal, session, streams)
old_timer = getattr(session, 'proposal_timer', None)
assert old_timer is None
session.proposal_timer = timer
def _NH_SIPSessionProposalRejected(self, notification):
if notification.data.originator == 'remote':
session = notification.sender
timer = getattr(session, 'proposal_timer', None)
if timer is not None:
timer.cancel()
session.proposal_timer = None
def _NH_SIPSessionHadProposalFailure(self, notification):
if notification.data.originator == 'remote':
session = notification.sender
timer = getattr(session, 'proposal_timer', None)
assert timer is not None
timer.cancel()
session.proposal_timer = None
def _NH_SIPSessionDidRenegotiateStreams(self, notification):
session = notification.sender
for stream in notification.data.added_streams:
notification.center.add_observer(self, sender=stream)
txt = u'%s has added %s' % (format_identity(session.remote_identity), stream.type)
log.msg(u'Room %s - %s' % (self.uri, txt))
self.dispatch_server_message(txt, exclude=session)
if stream.type == 'audio':
log.msg(u'Room %s - audio stream %s/%sHz, end-points: %s:%d <-> %s:%d' % (self.uri, stream.codec, stream.sample_rate,
stream.local_rtp_address, stream.local_rtp_port,
stream.remote_rtp_address, stream.remote_rtp_port))
if stream.encryption.type != 'ZRTP':
# We don't listen for stream notifications early enough
if stream.encryption.active:
log.msg(u'Room %s - %s %s stream enabled %s encryption' % (self.uri,
format_identity(session.remote_identity),
stream.type,
stream.encryption.type))
else:
log.msg(u'Room %s - %s %s stream did not enable encryption' % (self.uri,
format_identity(session.remote_identity),
stream.type))
if notification.data.added_streams:
welcome_handler = WelcomeHandler(self, initial=False, session=session, streams=notification.data.added_streams)
welcome_handler.run()
for stream in notification.data.removed_streams:
notification.center.remove_observer(self, sender=stream)
txt = u'%s has removed %s' % (format_identity(session.remote_identity), stream.type)
log.msg(u'Room %s - %s' % (self.uri, txt))
self.dispatch_server_message(txt, exclude=session)
if stream.type == 'audio':
try:
self.audio_conference.remove(stream)
except ValueError:
# User may hangup before getting bridged into the conference
pass
if len(self.audio_conference.streams) == 0:
self.moh_player.pause()
self.audio_conference.hold()
elif len(self.audio_conference.streams) == 1:
self.moh_player.play()
if not session.streams:
log.msg(u'Room %s - %s has removed all streams, session will be terminated' % (self.uri, format_identity(session.remote_identity)))
session.end()
self.dispatch_conference_info()
def _NH_SIPSessionTransferNewIncoming(self, notification):
log.msg(u'Room %s - Call transfer request rejected, REFER must be out of dialog (RFC4579 5.5)' % self.uri)
notification.sender.reject_transfer(403)
def _NH_SIPSessionWillEnd(self, notification):
session = notification.sender
timer = getattr(session, 'proposal_timer', None)
if timer is not None and timer.active():
timer.cancel()
session.proposal_timer = None
@staticmethod
def format_stream_types(streams):
if not streams:
return ''
if len(streams) == 1:
txt = 'with %s' % streams[0].type
else:
txt = 'with %s' % ','.join(stream.type for stream in streams[:-1])
txt += ' and %s' % streams[-1:][0].type
return txt
@staticmethod
def format_conference_stream_type(stream):
if stream.type == 'chat':
return 'message'
return stream.type
@staticmethod
def format_session_duration(session):
if session.start_time:
duration = session.end_time - session.start_time
seconds = duration.seconds if duration.microseconds < 500000 else duration.seconds+1
minutes, seconds = seconds / 60, seconds % 60
hours, minutes = minutes / 60, minutes % 60
hours += duration.days*24
if not minutes and not hours:
duration_text = '%d seconds' % seconds
elif not hours:
duration_text = '%02d:%02d' % (minutes, seconds)
else:
duration_text = '%02d:%02d:%02d' % (hours, minutes, seconds)
else:
duration_text = '0s'
return duration_text
@staticmethod
def format_file_size(size):
infinite = float('infinity')
boundaries = [( 1024, '%d bytes', 1),
( 10*1024, '%.2f KB', 1024.0), ( 1024*1024, '%.1f KB', 1024.0),
( 10*1024*1024, '%.2f MB', 1024*1024.0), (1024*1024*1024, '%.1f MB', 1024*1024.0),
(10*1024*1024*1024, '%.2f GB', 1024*1024*1024.0), ( infinite, '%.1f GB', 1024*1024*1024.0)]
for boundary, format, divisor in boundaries:
if size < boundary:
return format % (size/divisor,)
else:
return "%d bytes" % size
class MoHPlayer(object):
implements(IObserver)
def __init__(self, conference):
self.conference = conference
self.files = None
self.paused = None
self._player = None
def start(self):
files = glob('%s/*.wav' % Resources.get('sounds/moh'))
if not files:
log.error(u'No files found, MoH is disabled')
return
random.shuffle(files)
self.files = cycle(files)
self._player = WavePlayer(SIPApplication.voice_audio_mixer, '', pause_time=1, initial_delay=1, volume=20)
self.paused = True
self.conference.bridge.add(self._player)
NotificationCenter().add_observer(self, sender=self._player)
def stop(self):
if self._player is None:
return
NotificationCenter().remove_observer(self, sender=self._player)
self._player.stop()
self.paused = True
self.conference.bridge.remove(self._player)
self.conference = None
def play(self):
if self._player is not None and self.paused:
self.paused = False
self._play_next_file()
def pause(self):
if self._player is not None and not self.paused:
self.paused = True
self._player.stop()
def _play_next_file(self):
self._player.filename = next(self.files)
self._player.play()
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_WavePlayerDidFail(self, notification):
if not self.paused:
self._play_next_file()
_NH_WavePlayerDidEnd = _NH_WavePlayerDidFail
class WelcomeHandler(object):
implements(IObserver)
def __init__(self, room, initial, session, streams):
self.room = room
self.initial = initial
self.session = session
self.streams = streams
self.procs = proc.RunningProcSet()
@run_in_green_thread
def run(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.session)
for stream in self.streams:
if stream.type == 'audio':
self.procs.spawn(self.audio_welcome, stream)
elif stream.type == 'chat':
self.procs.spawn(self.chat_welcome, stream)
self.procs.waitall()
notification_center.remove_observer(self, sender=self.session)
self.session = None
self.streams = None
self.room = None
self.procs = None
def play_file_in_player(self, player, file, delay):
player.filename = file
player.pause_time = delay
try:
player.play().wait()
except WavePlayerError, e:
log.warning(u"Error playing file %s: %s" % (file, e))
def audio_welcome(self, stream):
player = WavePlayer(stream.mixer, '', pause_time=1, initial_delay=1, volume=50)
stream.bridge.add(player)
try:
if self.initial:
file = Resources.get('sounds/co_welcome_conference.wav')
self.play_file_in_player(player, file, 1)
user_count = len(set(str(s.remote_identity.uri) for s in self.room.sessions if any(stream for stream in s.streams if stream.type == 'audio')) - set([str(self.session.remote_identity.uri)]))
if user_count == 0:
file = Resources.get('sounds/co_only_one.wav')
self.play_file_in_player(player, file, 0.5)
elif user_count == 1:
file = Resources.get('sounds/co_there_is_one.wav')
self.play_file_in_player(player, file, 0.5)
elif user_count < 100:
file = Resources.get('sounds/co_there_are.wav')
self.play_file_in_player(player, file, 0.2)
if user_count <= 24:
file = Resources.get('sounds/bi_%d.wav' % user_count)
self.play_file_in_player(player, file, 0.1)
else:
file = Resources.get('sounds/bi_%d0.wav' % (user_count / 10))
self.play_file_in_player(player, file, 0.1)
file = Resources.get('sounds/bi_%d.wav' % (user_count % 10))
self.play_file_in_player(player, file, 0.1)
file = Resources.get('sounds/co_more_participants.wav')
self.play_file_in_player(player, file, 0)
file = Resources.get('sounds/connected_tone.wav')
self.play_file_in_player(player, file, 0.1)
except proc.ProcExit:
# No need to remove the bridge from the stream, it's done automatically
pass
else:
stream.bridge.remove(player)
self.room.audio_conference.add(stream)
self.room.audio_conference.unhold()
if len(self.room.audio_conference.streams) == 1:
self.room.moh_player.play()
else:
self.room.moh_player.pause()
finally:
player.stop()
def chat_welcome(self, stream):
if self.initial:
txt = 'Welcome to SylkServer!'
else:
txt = ''
user_count = len(set(str(s.remote_identity.uri) for s in self.room.sessions) - set([str(self.session.remote_identity.uri)]))
if user_count == 0:
txt += ' You are the first participant'
else:
if user_count == 1:
txt += ' There is one more participant'
else:
txt += ' There are %s more participants' % user_count
txt += ' in this conference room.'
if not ServerConfig.enable_bonjour:
if self.room.config.advertise_xmpp_support or self.room.config.pstn_access_numbers:
txt += '\n\nOther participants can join at these addresses:\n\n'
if self.room.config.pstn_access_numbers:
if len(self.room.config.pstn_access_numbers) == 1:
nums = self.room.config.pstn_access_numbers[0]
else:
nums = ', '.join(self.room.config.pstn_access_numbers[:-1]) + ' or %s' % self.room.config.pstn_access_numbers[-1]
txt += ' - Using a landline or mobile phone, dial %s (audio)\n' % nums
if self.room.config.advertise_xmpp_support:
txt += ' - Using an XMPP client, connect to group chat room %s (chat)\n' % self.room.uri
txt += ' - Using an XMPP Jingle capable client, add contact %s and call it (audio)\n' % self.room.uri
txt += ' - Using a SIP client, initiate a session to %s (audio and chat)\n' % self.room.uri
if self.room.config.webrtc_gateway_url:
txt += ' - Using a WebRTC enabled browser go to %s and join room %s\n' % (self.room.config.webrtc_gateway_url, self.room.identity.uri.user)
stream.send_message(txt, 'text/plain', sender=self.room.identity, recipients=[self.room.identity])
for msg in self.room.history:
stream.send_message(msg.content, msg.content_type, sender=msg.sender, recipients=[self.room.identity], timestamp=msg.timestamp)
# Send ZRTP SAS over the chat stream, if applicable
if self.room.config.zrtp_auto_verify:
session = stream.session
try:
audio_stream = next(stream for stream in session.streams if stream.type=='audio')
except StopIteration:
pass
else:
if audio_stream.encryption.type == 'ZRTP' and audio_stream.encryption.active:
# Only send the message if there are no relays in between
secure_chat = stream.transport == 'tls' and all(len(path)==1 for path in (stream.msrp.full_local_path, stream.msrp.full_remote_path))
sas = audio_stream.encryption.zrtp.sas
if sas is not None and secure_chat:
txt = 'Received ZRTP Short Authentication String: %s' % sas
# Don't set the remote identity, that way it will appear as a private message
ns = CPIMNamespace('urn:ag-projects:xml:ns:cpim', prefix='agp')
message_type = CPIMHeader('Message-Type', ns, 'status')
stream.send_message(txt, 'text/plain', sender=self.room.identity, additional_headers=[message_type])
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionWillEnd(self, notification):
self.procs.killall()
class RoomFile(object):
def __init__(self, name, hash, size, sender):
self.name = name
self.hash = hash
self.size = size
self.sender = sender
@property
def file_selector(self):
return FileSelector.for_file(self.name, hash=self.hash)
class FileTransferHandler(object):
implements(IObserver)
def __init__(self, room):
self.room = weakref.ref(room)
self.session = None
self.stream = None
self.handler = None
self.direction = None
def init_incoming(self, stream):
self.direction = 'incoming'
self.stream = stream
self.session = stream.session
self.handler = stream.handler
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.stream)
notification_center.add_observer(self, sender=self.handler)
@run_in_green_thread
def init_outgoing(self, destination, file):
self.direction = 'outgoing'
room = self.room()
if room is None:
return
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = SIPURI.new(destination)
lookup = DNSLookup()
try:
route = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()[0]
except (DNSLookupError, IndexError):
return
self.session = Session(account)
self.stream = MediaStreamRegistry.get('file-transfer')(file.file_selector, 'sendonly')
self.handler = self.stream.handler
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.stream)
notification_center.add_observer(self, sender=self.handler)
from_header = FromHeader(SIPURI.new(room.identity.uri), u'Conference File Transfer')
to_header = ToHeader(SIPURI.new(destination))
extra_headers = []
if ThorNodeConfig.enabled:
extra_headers.append(Header('Thor-Scope', 'conference-invitation'))
extra_headers.append(Header('X-Originator-From', str(file.sender.uri)))
extra_headers.append(SubjectHeader(u'File uploaded by %s' % file.sender))
self.session.connect(from_header, to_header, route=route, streams=[self.stream], is_focus=True, extra_headers=extra_headers)
def _terminate(self, failure_reason=None):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=self.stream)
notification_center.remove_observer(self, sender=self.handler)
room = self.room()
if room is not None:
if failure_reason is None:
if self.direction == 'incoming' and self.stream.direction == 'recvonly':
sender = ChatIdentity(self.session.remote_identity.uri, self.session.remote_identity.display_name)
file = RoomFile(self.stream.file_selector.name, self.stream.file_selector.hash, self.stream.file_selector.size, sender)
room.add_file(file)
else:
room.dispatch_server_message('File transfer for %s failed: %s' % (os.path.basename(self.stream.file_selector.name), failure_reason))
self.session = None
self.stream = None
self.handler = None
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_MediaStreamDidNotInitialize(self, notification):
self._terminate(failure_reason=notification.data.reason)
def _NH_FileTransferHandlerDidEnd(self, notification):
if self.direction == 'incoming':
if self.stream.direction == 'sendonly':
reactor.callLater(3, self.session.end)
else:
reactor.callLater(1, self.session.end)
else:
self.session.end()
self._terminate(failure_reason=notification.data.reason)
diff --git a/sylk/applications/conference/web.py b/sylk/applications/conference/web.py
index d11b177..0b5dc1f 100644
--- a/sylk/applications/conference/web.py
+++ b/sylk/applications/conference/web.py
@@ -1,85 +1,83 @@
-# Copyright (C) 2011 AG Projects. See LICENSE for details
-#
import os
import urllib
from application.python.types import Singleton
from twisted.web.resource import ErrorPage, NoResource
from twisted.web.static import File
from sylk.applications.conference.configuration import ConferenceConfig
from sylk.web import Klein
class ConferenceWeb(object):
__metaclass__ = Singleton
app = Klein()
screensharing_template = """
SylkServer Screen Sharing
s)
"""
def __init__(self, conference):
self.conference = conference
def resource(self):
return self.app.resource()
@app.route('/')
def home(self, request):
return NoResource('Nothing to see here, move along.')
@app.route('/')
def room(self, request, room_uri):
return NoResource('Nothing to see here, move along.')
@app.route('//screensharing')
def scheensharing(self, request, room_uri):
try:
room = self.conference._rooms[room_uri]
except KeyError:
return NoResource('Room not found')
request.setHeader('Content-Type', 'text/html; charset=utf-8')
if 'image' not in request.args or not request.args.get('image', [''])[0].endswith('jpg'):
return ErrorPage(400, 'Bad Request', '\"image\" not provided')
images_path = os.path.join(ConferenceConfig.screensharing_images_dir, room.uri)
image_path = os.path.basename(urllib.unquote(request.args['image'][0]))
if not os.path.isfile(os.path.join(images_path, image_path)):
return NoResource('Image not found')
image = os.path.join('screensharing_img', image_path)
width = 'width: 100%' if 'fit' in request.args else ''
return self.screensharing_template % dict(image=image, width=width)
@app.route('//screensharing_img/')
def screensharing_image(self, request, room_uri, filename):
try:
room = self.conference._rooms[room_uri]
except KeyError:
return NoResource('Room not found')
images_path = os.path.join(ConferenceConfig.screensharing_images_dir, room.uri)
return File(os.path.join(images_path, os.path.basename(filename)))
diff --git a/sylk/applications/echo/__init__.py b/sylk/applications/echo/__init__.py
index 4bc7530..2c03bad 100644
--- a/sylk/applications/echo/__init__.py
+++ b/sylk/applications/echo/__init__.py
@@ -1,163 +1,161 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
from application.notification import IObserver, NotificationCenter
from application.python import Null
from sipsimple.account.bonjour import BonjourPresenceState
from twisted.internet import reactor
from zope.interface import implements
from sylk.applications import SylkApplication, ApplicationLogger
from sylk.bonjour import BonjourService
from sylk.configuration import ServerConfig
log = ApplicationLogger.for_package(__package__)
def format_identity(identity):
if identity.display_name:
return u'%s ' % (identity.display_name, identity.uri.user, identity.uri.host)
else:
return u'sip:%s@%s' % (identity.uri.user, identity.uri.host)
class EchoApplication(SylkApplication):
implements(IObserver)
def __init__(self):
self.pending = set()
self.sessions = set()
self.bonjour_services = set()
def start(self):
if ServerConfig.enable_bonjour:
application_map = dict((item.split(':')) for item in ServerConfig.application_map)
for uri, app in application_map.iteritems():
if app == 'echo':
service = BonjourService(service='sipuri', name='Echo Test', uri_user=uri, is_focus=False)
service.start()
service.presence_state = BonjourPresenceState('available', u'Call me to test your client')
self.bonjour_services.add(service)
def stop(self):
self.pending.clear()
self.sessions.clear()
for service in self.bonjour_services:
service.stop()
self.bonjour_services.clear()
def incoming_session(self, session):
log.msg(u'New incoming session %s from %s' % (session.call_id, format_identity(session.remote_identity)))
audio_streams = [stream for stream in session.proposed_streams if stream.type=='audio']
chat_streams = [stream for stream in session.proposed_streams if stream.type=='chat']
if not audio_streams and not chat_streams:
log.msg(u'Session %s rejected: invalid media, only RTP audio and MSRP chat are supported' % session.call_id)
session.reject(488)
return
NotificationCenter().add_observer(self, sender=session)
if audio_streams:
session.send_ring_indication()
streams = [streams[0] for streams in (audio_streams, chat_streams) if streams]
reactor.callLater(2 if audio_streams else 0, self._accept_session, session, streams)
self.pending.add(session)
session._end_timer = None
def incoming_subscription(self, request, data):
request.reject(405)
def incoming_referral(self, request, data):
request.reject(405)
def incoming_message(self, request, data):
request.reject(405)
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _accept_session(self, session, streams):
if session in self.pending:
session.accept(streams)
def _make_audio_stream_echo(self, stream):
if stream.producer_slot is not None and stream.consumer_slot is not None:
# TODO: handle slot changes
stream.bridge.remove(stream.device)
stream.mixer.connect_slots(stream.producer_slot, stream.consumer_slot)
def _NH_SIPSessionDidStart(self, notification):
session = notification.sender
self.pending.remove(session)
self.sessions.add(session)
try:
audio_stream = next(stream for stream in session.streams if stream.type == 'audio')
except StopIteration:
audio_stream = None
try:
chat_stream = next(stream for stream in session.streams if stream.type == 'chat')
except StopIteration:
chat_stream = None
log.msg('Session %s started' % session.call_id)
if audio_stream is not None:
self._make_audio_stream_echo(audio_stream)
notification.center.add_observer(self, sender=audio_stream)
if chat_stream is not None:
notification.center.add_observer(self, sender=chat_stream)
session._end_timer = reactor.callLater(600, session.end)
def _NH_SIPSessionDidEnd(self, notification):
session = notification.sender
log.msg('Session %s ended' % session.call_id)
notification.center.remove_observer(self, sender=session)
# We could get DidEnd even if we never got DidStart
self.sessions.discard(session)
self.pending.discard(session)
if session._end_timer is not None and session._end_timer.active():
session._end_timer.cancel()
session._end_timer = None
def _NH_SIPSessionDidFail(self, notification):
session = notification.sender
log.msg(u'Session %s failed from %s' % (session.call_id, format_identity(session.remote_identity)))
self.pending.remove(session)
notification.center.remove_observer(self, sender=session)
if session._end_timer is not None and session._end_timer.active():
session._end_timer.cancel()
session._end_timer = None
def _NH_ChatStreamGotMessage(self, notification):
stream = notification.sender
message = notification.data.message
stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
stream.send_message(message.content, message.content_type)
def _NH_SIPSessionNewProposal(self, notification):
if notification.data.originator == 'remote':
session = notification.sender
audio_streams = [stream for stream in notification.data.proposed_streams if stream.type=='audio']
chat_streams = [stream for stream in notification.data.proposed_streams if stream.type=='chat']
if not audio_streams and not chat_streams:
session.reject_proposal()
return
streams = [streams[0] for streams in (audio_streams, chat_streams) if streams]
session.accept_proposal(streams)
def _NH_SIPSessionDidRenegotiateStreams(self, notification):
session = notification.sender
for stream in notification.data.added_streams:
notification.center.add_observer(self, sender=stream)
log.msg(u'Session %s has added %s' % (session.call_id, stream.type))
if stream.type == 'audio':
self._make_audio_stream_echo(stream)
for stream in notification.data.removed_streams:
notification.center.remove_observer(self, sender=stream)
log.msg(u'Session %s has removed %s' % (session.call_id, stream.type))
if not session.streams:
log.msg(u'Session %s has removed all streams, session will be terminated' % session.call_id)
session.end()
def _NH_SIPSessionTransferNewIncoming(self, notification):
notification.sender.reject_transfer(403)
diff --git a/sylk/applications/ircconference/__init__.py b/sylk/applications/ircconference/__init__.py
index 941c8fa..275bafb 100644
--- a/sylk/applications/ircconference/__init__.py
+++ b/sylk/applications/ircconference/__init__.py
@@ -1,100 +1,98 @@
-# Copyright (C) 2011 AG Projects. See LICENSE for details
-#
from application.notification import IObserver, NotificationCenter
from application.python import Null
from twisted.internet import reactor
from zope.interface import implements
from sylk.applications import SylkApplication
from sylk.applications.ircconference.logger import log
from sylk.applications.ircconference.room import IRCRoom
class IRCConferenceApplication(SylkApplication):
implements(IObserver)
def __init__(self):
self.rooms = set()
self.pending_sessions = []
def start(self):
pass
def stop(self):
pass
def incoming_session(self, session):
log.msg('New incoming session from %s' % session.remote_identity.uri)
audio_streams = [stream for stream in session.proposed_streams if stream.type=='audio']
chat_streams = [stream for stream in session.proposed_streams if stream.type=='chat']
if not audio_streams and not chat_streams:
session.reject(488)
return
self.pending_sessions.append(session)
NotificationCenter().add_observer(self, sender=session)
if audio_streams:
session.send_ring_indication()
if chat_streams:
for stream in chat_streams:
# Disable chatroom capabilities other than nickname
stream.chatroom_capabilities = ['nickname']
streams = [streams[0] for streams in (audio_streams, chat_streams) if streams]
reactor.callLater(4 if audio_streams else 0, self.accept_session, session, streams)
def incoming_subscription(self, subscribe_request, data):
to_header = data.headers.get('To', Null)
if to_header is Null:
subscribe_request.reject(400)
return
room = IRCRoom.get_room(data.request_uri)
if not room.started:
room = IRCRoom.get_room(to_header.uri)
if not room.started:
subscribe_request.reject(480)
return
room.handle_incoming_subscription(subscribe_request, data)
def incoming_referral(self, request, data):
request.reject(405)
def incoming_message(self, request, data):
request.reject(405)
def accept_session(self, session, streams):
if session in self.pending_sessions:
session.accept(streams, is_focus=True)
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionDidStart(self, notification):
session = notification.sender
self.pending_sessions.remove(session)
room = IRCRoom.get_room(session.request_uri)
room.start()
room.add_session(session)
self.rooms.add(room)
def _NH_SIPSessionDidEnd(self, notification):
session = notification.sender
log.msg('Session from %s ended' % session.remote_identity.uri)
NotificationCenter().remove_observer(self, sender=session)
room = IRCRoom.get_room(session.request_uri)
if session in room.sessions:
# We could get this notifiction even if we didn't get SIPSessionDidStart
room.remove_session(session)
if room.empty:
room.stop()
try:
self.rooms.remove(room)
except KeyError:
pass
def _NH_SIPSessionDidFail(self, notification):
session = notification.sender
self.pending_sessions.remove(session)
log.msg('Session from %s failed' % session.remote_identity.uri)
diff --git a/sylk/applications/ircconference/configuration.py b/sylk/applications/ircconference/configuration.py
index ed8766f..b15194e 100644
--- a/sylk/applications/ircconference/configuration.py
+++ b/sylk/applications/ircconference/configuration.py
@@ -1,31 +1,29 @@
-# Copyright (C) 2011 AG Projects. See LICENSE for details.
-#
__all__ = ['get_room_configuration']
from application.configuration import ConfigSection, ConfigSetting
from application.configuration.datatypes import EndpointAddress
def get_room_configuration(room):
IRCConferenceConfig.read(section=room)
config = Configuration(dict(IRCConferenceConfig))
IRCConferenceConfig.reset()
return config
class Configuration(object):
def __init__(self, data):
self.__dict__.update(data)
class IRCServer(EndpointAddress):
default_port = 6667
name = 'IRC server address'
class IRCConferenceConfig(ConfigSection):
__cfgfile__ = 'ircconference.ini'
channel = 'test'
server = ConfigSetting(type=IRCServer, value='irc.freenode.net:6667')
website = 'http://sylkserver.com'
diff --git a/sylk/applications/ircconference/logger.py b/sylk/applications/ircconference/logger.py
index 1fc09c6..e2405c7 100644
--- a/sylk/applications/ircconference/logger.py
+++ b/sylk/applications/ircconference/logger.py
@@ -1,9 +1,7 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
__all__ = ['log']
from sylk.applications import ApplicationLogger
log = ApplicationLogger.for_package(__package__)
diff --git a/sylk/applications/ircconference/room.py b/sylk/applications/ircconference/room.py
index 9a8e676..87584a2 100644
--- a/sylk/applications/ircconference/room.py
+++ b/sylk/applications/ircconference/room.py
@@ -1,670 +1,668 @@
-# Copyright (C) 2011 AG Projects. See LICENSE for details.
-#
import random
import urllib
import lxml.html
import lxml.html.clean
from itertools import count
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.types import Singleton
from eventlib import coros, proc
from sipsimple.audio import AudioConference, WavePlayer, WavePlayerError
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import SIPURI, SIPCoreError, SIPCoreInvalidStateError
from sipsimple.payloads.conference import Conference, ConferenceDocument, ConferenceDescription, ConferenceState, Endpoint, EndpointStatus, HostInfo, JoiningInfo, Media, User, Users, WebPage
from sipsimple.streams.msrp.chat import ChatIdentity
from sipsimple.threading import run_in_twisted_thread
from sipsimple.threading.green import run_in_green_thread
from twisted.internet import protocol, reactor
from twisted.words.protocols import irc
from zope.interface import implements
from sylk.applications.ircconference.configuration import get_room_configuration
from sylk.applications.ircconference.logger import log
from sylk.resources import Resources
def format_identity(identity):
uri = identity.uri
if identity.display_name:
return u'%s ' % (identity.display_name, uri.user, uri.host)
else:
return u'sip:%s@%s' % (uri.user, uri.host)
def format_stream_types(streams):
if not streams:
return ''
if len(streams) == 1:
txt = 'with %s' % streams[0].type
else:
txt = 'with %s' % ','.join(stream.type for stream in streams[:-1])
txt += ' and %s' % streams[-1:][0].type
return txt
def format_session_duration(session):
if session.start_time:
duration = session.end_time - session.start_time
seconds = duration.seconds if duration.microseconds < 500000 else duration.seconds+1
minutes, seconds = seconds / 60, seconds % 60
hours, minutes = minutes / 60, minutes % 60
hours += duration.days*24
if not minutes and not hours:
duration_text = '%d seconds' % seconds
elif not hours:
duration_text = '%02d:%02d' % (minutes, seconds)
else:
duration_text = '%02d:%02d:%02d' % (hours, minutes, seconds)
else:
duration_text = '0s'
return duration_text
def format_conference_stream_type(stream):
if stream.type == 'chat':
return 'message'
return stream.type
def html2text(data):
try:
doc = lxml.html.document_fromstring(data)
cleaner = lxml.html.clean.Cleaner(style=True)
doc = cleaner.clean_html(doc)
return doc.text_content().strip('\n')
except Exception:
return ''
class IRCMessage(object):
def __init__(self, username, uri, content, content_type='text/plain'):
self.sender = ChatIdentity(uri, display_name=username)
self.content = content
self.content_type = content_type
class IRCRoom(object):
"""
Object representing a conference room, it will handle the message dispatching
among all the participants.
"""
__metaclass__ = Singleton
implements(IObserver)
def __init__(self, uri):
self.uri = uri
self.identity = ChatIdentity.parse('' % self.uri)
self.sessions = []
self.sessions_with_proposals = []
self.subscriptions = []
self.pending_messages = []
self.state = 'stopped'
self.incoming_message_queue = coros.queue()
self.message_dispatcher = None
self.audio_conference = None
self.conference_info_payload = None
self.conference_info_version = count(1)
self.irc_connector = None
self.irc_protocol = None
@classmethod
def get_room(cls, uri):
room_uri = '%s@%s' % (uri.user, uri.host)
room = cls(room_uri)
return room
@property
def empty(self):
return len(self.sessions) == 0
@property
def started(self):
return self.state == 'started'
def start(self):
if self.state != 'stopped':
return
config = get_room_configuration(self.uri.split('@')[0])
factory = IRCBotFactory(config)
host, port = config.server
self.irc_connector = reactor.connectTCP(host, port, factory)
NotificationCenter().add_observer(self, sender=self.irc_connector.factory)
self.message_dispatcher = proc.spawn(self._message_dispatcher)
self.audio_conference = AudioConference()
self.audio_conference.hold()
self.state = 'started'
def stop(self):
if self.state != 'started':
return
self.state = 'stopped'
NotificationCenter().remove_observer(self, sender=self.irc_connector.factory)
self.irc_connector.factory.stop_requested = True
self.irc_connector.disconnect()
self.irc_connector = None
self.message_dispatcher.kill(proc.ProcExit)
self.audio_conference = None
def _message_dispatcher(self):
"""Read from self.incoming_message_queue and dispatch the messages to other participants"""
while True:
session, message_type, data = self.incoming_message_queue.wait()
if message_type == 'msrp_message':
if data.sender.uri != session.remote_identity.uri:
return
self.dispatch_message(session, data)
elif message_type == 'irc_message':
self.dispatch_irc_message(data)
def dispatch_message(self, session, message):
identity = ChatIdentity.parse(format_identity(session.remote_identity, True))
for s in (s for s in self.sessions if s is not session):
try:
chat_stream = next(stream for stream in s.streams if stream.type == 'chat')
except StopIteration:
pass
else:
chat_stream.send_message(message.content, message.content_type, sender=identity, recipients=[self.identity], timestamp=message.timestamp)
def dispatch_irc_message(self, message):
for session in self.sessions:
try:
chat_stream = next(stream for stream in session.streams if stream.type == 'chat')
except StopIteration:
pass
else:
chat_stream.send_message(message.content, message.content_type, sender=message.sender, recipients=[self.identity])
def dispatch_server_message(self, content, content_type='text/plain', exclude=None):
for session in (session for session in self.sessions if session is not exclude):
try:
chat_stream = next(stream for stream in session.streams if stream.type == 'chat')
except StopIteration:
pass
else:
chat_stream.send_message(content, content_type, sender=self.identity, recipients=[self.identity])
def get_conference_info(self):
# Send request to get participants list, we'll get a notification with it
if self.irc_protocol is not None:
self.irc_protocol.get_participants()
else:
self.dispatch_conference_info([])
def dispatch_conference_info(self, irc_participants):
data = self.build_conference_info_payload(irc_participants)
for subscription in (subscription for subscription in self.subscriptions if subscription.state == 'active'):
try:
subscription.push_content(ConferenceDocument.content_type, data)
except (SIPCoreError, SIPCoreInvalidStateError):
pass
def build_conference_info_payload(self, irc_participants):
irc_configuration = get_room_configuration(self.uri.split('@')[0])
if self.conference_info_payload is None:
settings = SIPSimpleSettings()
conference_description = ConferenceDescription(display_text='#%s on %s' % (irc_configuration.channel, irc_configuration.server[0]), free_text='Hosted by %s' % settings.user_agent)
host_info = HostInfo(web_page=WebPage(irc_configuration.website))
self.conference_info_payload = Conference(self.identity.uri, conference_description=conference_description, host_info=host_info, users=Users())
self.conference_info_payload.version = next(self.conference_info_version)
user_count = len(set(str(s.remote_identity.uri) for s in self.sessions)) + len(irc_participants)
self.conference_info_payload.conference_state = ConferenceState(user_count=user_count, active=True)
users = Users()
for session in self.sessions:
try:
user = next(user for user in users if user.entity == str(session.remote_identity.uri))
except StopIteration:
user = User(str(session.remote_identity.uri), display_text=session.remote_identity.display_name)
users.add(user)
joining_info = JoiningInfo(when=session.start_time)
holdable_streams = [stream for stream in session.streams if stream.hold_supported]
session_on_hold = holdable_streams and all(stream.on_hold_by_remote for stream in holdable_streams)
hold_status = EndpointStatus('on-hold' if session_on_hold else 'connected')
endpoint = Endpoint(str(session._invitation.remote_contact_header.uri), display_text=session.remote_identity.display_name, joining_info=joining_info, status=hold_status)
for stream in session.streams:
endpoint.add(Media(id(stream), media_type=format_conference_stream_type(stream)))
user.add(endpoint)
for nick in irc_participants:
irc_uri = '%s@%s' % (urllib.quote(nick), irc_configuration.server[0])
user = User(irc_uri, display_text=nick)
users.add(user)
endpoint = Endpoint(irc_uri, display_text=nick)
endpoint.add(Media(random.randint(100000000, 999999999), media_type='message'))
user.add(endpoint)
self.conference_info_payload.users = users
return self.conference_info_payload.toxml()
def add_session(self, session):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=session)
self.sessions.append(session)
try:
chat_stream = next(stream for stream in session.streams if stream.type == 'chat')
except StopIteration:
pass
else:
notification_center.add_observer(self, sender=chat_stream)
try:
audio_stream = next(stream for stream in session.streams if stream.type == 'audio')
except StopIteration:
pass
else:
notification_center.add_observer(self, sender=audio_stream)
log.msg(u'Audio stream using %s/%sHz (%s), end-points: %s:%d <-> %s:%d' % (audio_stream.codec, audio_stream.sample_rate,
audio_stream.local_rtp_address, audio_stream.local_rtp_port,
audio_stream.remote_rtp_address, audio_stream.remote_rtp_port))
welcome_handler = WelcomeHandler(self, session)
welcome_handler.start()
self.get_conference_info()
if len(self.sessions) == 1:
log.msg(u'%s started conference %s %s' % (format_identity(session.remote_identity), self.uri, format_stream_types(session.streams)))
else:
log.msg(u'%s joined conference %s %s' % (format_identity(session.remote_identity), self.uri, format_stream_types(session.streams)))
if str(session.remote_identity.uri) not in set(str(s.remote_identity.uri) for s in self.sessions if s is not session):
self.dispatch_server_message('%s has joined the room %s' % (format_identity(session.remote_identity), format_stream_types(session.streams)), exclude=session)
def remove_session(self, session):
notification_center = NotificationCenter()
try:
chat_stream = next(stream for stream in session.streams or [] if stream.type == 'chat')
except StopIteration:
pass
else:
notification_center.remove_observer(self, sender=chat_stream)
try:
audio_stream = next(stream for stream in session.streams or [] if stream.type == 'audio')
except StopIteration:
pass
else:
notification_center.remove_observer(self, sender=audio_stream)
try:
self.audio_conference.remove(audio_stream)
except ValueError:
# User may hangup before getting bridged into the conference
pass
if len(self.audio_conference.streams) == 0:
self.audio_conference.hold()
notification_center.remove_observer(self, sender=session)
self.sessions.remove(session)
self.get_conference_info()
log.msg(u'%s left conference %s after %s' % (format_identity(session.remote_identity), self.uri, format_session_duration(session)))
if not self.sessions:
log.msg(u'Last participant left conference %s' % self.uri)
if str(session.remote_identity.uri) not in set(str(s.remote_identity.uri) for s in self.sessions if s is not session):
self.dispatch_server_message('%s has left the room after %s' % (format_identity(session.remote_identity), format_session_duration(session)))
def accept_proposal(self, session, streams):
if session in self.sessions_with_proposals:
session.accept_proposal(streams)
self.sessions_with_proposals.remove(session)
def handle_incoming_subscription(self, subscribe_request, data):
if subscribe_request.event != 'conference':
subscribe_request.reject(489)
return
NotificationCenter().add_observer(self, sender=subscribe_request)
subscribe_request.accept()
self.subscriptions.append(subscribe_request)
self.get_conference_info()
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPIncomingSubscriptionDidEnd(self, notification):
subscription = notification.sender
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=subscription)
self.subscriptions.remove(subscription)
def _NH_SIPSessionDidChangeHoldState(self, notification):
session = notification.sender
if notification.data.originator == 'remote':
if notification.data.on_hold:
log.msg(u'%s has put the audio session on hold' % format_identity(session.remote_identity))
else:
log.msg(u'%s has taken the audio session out of hold' % format_identity(session.remote_identity))
self.get_conference_info()
def _NH_SIPSessionNewProposal(self, notification):
if notification.data.originator == 'remote':
session = notification.sender
audio_streams = [stream for stream in notification.data.proposed_streams if stream.type=='audio']
chat_streams = [stream for stream in notification.data.proposed_streams if stream.type=='chat']
if not audio_streams and not chat_streams:
session.reject_proposal()
return
if chat_streams:
chat_streams[0].chatroom_capabilities = []
streams = [streams[0] for streams in (audio_streams, chat_streams) if streams]
self.sessions_with_proposals.append(session)
reactor.callLater(4, self.accept_proposal, session, streams)
def _NH_SIPSessionProposalRejected(self, notification):
session = notification.sender
self.sessions_with_proposals.remove(session)
def _NH_SIPSessionDidRenegotiateStreams(self, notification):
session = notification.sender
for stream in notification.data.added_streams:
notification.center.add_observer(self, sender=stream)
log.msg(u'%s has added %s to %s' % (format_identity(session.remote_identity), stream.type, self.uri))
self.dispatch_server_message('%s has added %s' % (format_identity(session.remote_identity), stream.type), exclude=session)
if stream.type == 'audio':
log.msg(u'Audio stream using %s/%sHz, end-points: %s:%d <-> %s:%d' % (stream.codec, stream.sample_rate,
stream.local_rtp_address, stream.local_rtp_port,
stream.remote_rtp_address, stream.remote_rtp_port))
welcome_handler = WelcomeHandler(self, session)
welcome_handler.start(welcome_prompt=False)
for stream in notification.data.removed_streams:
notification.center.remove_observer(self, sender=stream)
log.msg(u'%s has removed %s from %s' % (format_identity(session.remote_identity), stream.type, self.uri))
self.dispatch_server_message('%s has removed %s' % (format_identity(session.remote_identity), stream.type), exclude=session)
if stream.type == 'audio':
try:
self.audio_conference.remove(stream)
except ValueError:
# User may hangup before getting bridged into the conference
pass
if len(self.audio_conference.streams) == 0:
self.audio_conference.hold()
if not session.streams:
log.msg(u'%s has removed all streams from %s, session will be terminated' % (format_identity(session.remote_identity), self.uri))
session.end()
self.get_conference_info()
def _NH_RTPStreamDidTimeout(self, notification):
stream = notification.sender
if stream.type != 'audio':
return
session = stream.session
log.msg(u'Audio stream for session %s timed out' % format_identity(session.remote_identity))
if session.streams == [stream]:
session.end()
def _NH_ChatStreamGotMessage(self, notification):
stream = notification.sender
message = notification.data.message
if message.content_type not in ('text/html', 'text/plain'):
log.msg(u'Unsupported content type: %s, ignoring message' % message.content_type)
stream.msrp_session.send_report(notification.data.chunk, 413, 'Unwanted message')
return
stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
# Send MSRP chat message to other participants
session = stream.session
self.incoming_message_queue.send((session, 'msrp_message', message))
# Send MSRP chat message to IRC chat room
if message.content_type == 'text/html':
content = html2text(message.content)
elif message.content_type == 'text/plain':
content = message.content
else:
log.warning('unexpected message type: %s' % message.content_type)
return
sender = message.sender
irc_message = '%s: %s' % (format_identity(sender), content)
if self.irc_protocol is not None:
self.irc_protocol.send_message(irc_message.encode('utf-8'))
else:
self.pending_messages.append(irc_message)
def _NH_ChatStreamGotNicknameRequest(self, notification):
# Discard the nickname but pretend we accept it so that XMPP clients can work
chunk = notification.data.chunk
notification.sender.accept_nickname(chunk)
def _NH_IRCBotGotConnected(self, notification):
self.irc_protocol = notification.data.protocol
# Send enqueued messages
while self.pending_messages:
message = self.pending_messages.pop(0)
self.irc_protocol.send_message(message.encode('utf-8'))
# Update participants list
self.get_conference_info()
def _NH_IRCBotGotDisconnected(self, notification):
self.irc_protocol = None
def _NH_IRCBotGotMessage(self, notification):
message = notification.data.message
self.incoming_message_queue.send((None, 'irc_message', message))
def _NH_IRCBotGotParticipantsList(self, notification):
self.dispatch_conference_info(notification.data.participants)
def _NH_IRCBotJoinedChannel(self, notification):
self.get_conference_info()
def _NH_IRCBotUserJoined(self, notification):
self.dispatch_server_message('%s joined the IRC channel' % notification.data.user)
self.get_conference_info()
def _NH_IRCBotUserLeft(self, notification):
self.dispatch_server_message('%s left the IRC channel' % notification.data.user)
self.get_conference_info()
def _NH_IRCBotUserQuit(self, notification):
self.dispatch_server_message('%s quit the IRC channel: %s' % (notification.data.user, notification.data.reason))
self.get_conference_info()
def _NH_IRCBotUserKicked(self, notification):
data = notification.data
self.dispatch_server_message('%s kicked %s out of the IRC channel: %s' % (data.kicker, data.kickee, data.reason))
self.get_conference_info()
def _NH_IRCBotUserRenamed(self, notification):
self.dispatch_server_message('%s changed his name to %s' % (notification.data.oldname, notification.data.newname))
self.get_conference_info()
def _NH_IRCBotUserAction(self, notification):
self.dispatch_server_message('%s %s' % (notification.data.user, notification.data.action))
class WelcomeHandler(object):
implements(IObserver)
def __init__(self, room, session):
self.room = room
self.session = session
self.proc = None
@run_in_green_thread
def start(self, welcome_prompt=True):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.session)
self.proc = proc.spawn(self.play_audio_welcome, welcome_prompt)
self.proc.wait()
notification_center.remove_observer(self, sender=self.session)
self.session = None
self.room = None
self.proc = None
def play_file_in_player(self, player, file, delay):
player.filename = file
player.pause_time = delay
try:
player.play().wait()
except WavePlayerError, e:
log.warning(u"Error playing file %s: %s" % (file, e))
def play_audio_welcome(self, welcome_prompt):
try:
audio_stream = next(stream for stream in self.session.streams if stream.type == 'audio')
except StopIteration:
return
player = WavePlayer(audio_stream.mixer, '', pause_time=1, initial_delay=1, volume=50)
audio_stream.bridge.add(player)
try:
if welcome_prompt:
file = Resources.get('sounds/co_welcome_conference.wav')
self.play_file_in_player(player, file, 1)
user_count = len(set(str(s.remote_identity.uri) for s in self.room.sessions if any(stream for stream in s.streams if stream.type == 'audio')) - set([str(self.session.remote_identity.uri)]))
if user_count == 0:
file = Resources.get('sounds/co_only_one.wav')
self.play_file_in_player(player, file, 0.5)
elif user_count == 1:
file = Resources.get('sounds/co_there_is_one.wav')
self.play_file_in_player(player, file, 0.5)
elif user_count < 100:
file = Resources.get('sounds/co_there_are.wav')
self.play_file_in_player(player, file, 0.2)
if user_count <= 24:
file = Resources.get('sounds/bi_%d.wav' % user_count)
self.play_file_in_player(player, file, 0.1)
else:
file = Resources.get('sounds/bi_%d0.wav' % (user_count / 10))
self.play_file_in_player(player, file, 0.1)
file = Resources.get('sounds/bi_%d.wav' % (user_count % 10))
self.play_file_in_player(player, file, 0.1)
file = Resources.get('sounds/co_more_participants.wav')
self.play_file_in_player(player, file, 0)
file = Resources.get('sounds/connected_tone.wav')
self.play_file_in_player(player, file, 0.1)
except proc.ProcExit:
# No need to remove the bridge from the stream, it's done automatically
pass
else:
audio_stream.bridge.remove(player)
self.room.audio_conference.add(audio_stream)
self.room.audio_conference.unhold()
finally:
player.stop()
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionWillEnd(self, notification):
self.proc.kill()
class IRCBot(irc.IRCClient):
nickname = 'SylkServer'
def __init__(self):
self._nick_collector = []
self.nicks = []
def connectionMade(self):
irc.IRCClient.connectionMade(self)
log.msg('Connection to IRC has been established')
NotificationCenter().post_notification('IRCBotGotConnected', self.factory, NotificationData(protocol=self))
def connectionLost(self, failure):
irc.IRCClient.connectionLost(self, failure)
NotificationCenter().post_notification('IRCBotGotDisconnected', self.factory, NotificationData())
def signedOn(self):
log.msg('Logging into %s channel...' % self.factory.channel)
self.join(self.factory.channel)
def kickedFrom(self, channel, kicker, message):
log.msg('Got kicked from %s by %s: %s. Rejoining...' % (channel, kicker, message))
self.join(self.factory.channel)
def joined(self, channel):
log.msg('Logged into %s channel' % channel)
NotificationCenter().post_notification('IRCBotJoinedChannel', self.factory, NotificationData(channel=self.factory.channel))
def privmsg(self, user, channel, message):
if channel == '*':
return
username = user.split('!', 1)[0]
if username == self.nickname:
return
if channel == self.nickname:
self.msg(username, "Sorry, I don't support private messages, I'm a bot.")
return
uri = SIPURI.parse('sip:%s@%s' % (urllib.quote(username), self.factory.config.server[0]))
irc_message = IRCMessage(username, uri, message.decode('utf-8'))
data = NotificationData(message=irc_message)
NotificationCenter().post_notification('IRCBotGotMessage', self.factory, data)
def send_message(self, message):
self.say(self.factory.channel, message)
def get_participants(self):
self.sendLine("NAMES #%s" % self.factory.channel)
def got_participants(self, nicks):
data = NotificationData(participants=nicks)
NotificationCenter().post_notification('IRCBotGotParticipantsList', self.factory, data)
def irc_RPL_NAMREPLY(self, prefix, params):
"""Collect usernames from this channel. Several of these
messages may be sent to cover the channel's full nicklist.
An RPL_ENDOFNAMES signals the end of the list.
"""
# We just separate these into individual nicks and stuff them in
# the nickCollector, transferred to 'nicks' when we get the RPL_ENDOFNAMES.
for name in params[3].split():
# Remove operator and voice prefixes
if name[0] in '@+':
name = name[1:]
if name != self.nickname:
self._nick_collector.append(name)
def irc_RPL_ENDOFNAMES(self, prefix, params):
"""This is sent after zero or more RPL_NAMREPLY commands to
terminate the list of users in a channel.
"""
self.nicks = self._nick_collector
self._nick_collector = []
self.got_participants(self.nicks)
def userJoined(self, user, channel):
if channel.strip('#') == self.factory.channel:
data = NotificationData(user=user)
NotificationCenter().post_notification('IRCBotUserJoined', self.factory, data)
def userLeft(self, user, channel):
if channel.strip('#') == self.factory.channel:
data = NotificationData(user=user)
NotificationCenter().post_notification('IRCBotUserLeft', self.factory, data)
def userQuit(self, user, reason):
data = NotificationData(user=user, reason=reason)
NotificationCenter().post_notification('IRCBotUserQuit', self.factory, data)
def userKicked(self, kickee, channel, kicker, message):
if channel.strip('#') == self.factory.channel:
data = NotificationData(kickee=kickee, kicker=kicker, reason=message)
NotificationCenter().post_notification('IRCBotUserKicked', self.factory, data)
def userRenamed(self, oldname, newname):
data = NotificationData(oldname=oldname, newname=newname)
NotificationCenter().post_notification('IRCBotUserRenamed', self.factory, data)
def action(self, user, channel, data):
if channel.strip('#') == self.factory.channel:
username = user.split('!', 1)[0]
data = NotificationData(user=username, action=data)
NotificationCenter().post_notification('IRCBotUserAction', self.factory, data)
class IRCBotFactory(protocol.ClientFactory):
protocol = IRCBot
def __init__(self, config):
self.config = config
self.channel = config.channel
self.stop_requested = False
def clientConnectionLost(self, connector, failure):
log.msg('Disconnected from IRC: %s' % failure.getErrorMessage())
if not self.stop_requested:
log.msg('Reconnecting...')
connector.connect()
def clientConnectionFailed(self, connector, failure):
log.error('Connection to IRC server failed: %s' % failure.getErrorMessage())
diff --git a/sylk/applications/playback/__init__.py b/sylk/applications/playback/__init__.py
index c45b8d0..608c57b 100644
--- a/sylk/applications/playback/__init__.py
+++ b/sylk/applications/playback/__init__.py
@@ -1,171 +1,169 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
import os
from application.python import Null
from application.notification import IObserver, NotificationCenter
from eventlib import proc
from sipsimple.account.bonjour import BonjourPresenceState
from sipsimple.audio import WavePlayer, WavePlayerError
from twisted.internet import reactor
from zope.interface import implements
from sylk.applications import SylkApplication, ApplicationLogger
from sylk.applications.playback.configuration import get_config
from sylk.bonjour import BonjourService
from sylk.configuration import ServerConfig
log = ApplicationLogger.for_package(__package__)
class PlaybackApplication(SylkApplication):
def start(self):
self.bonjour_services = []
if ServerConfig.enable_bonjour:
application_map = dict((item.split(':')) for item in ServerConfig.application_map)
for uri, app in application_map.iteritems():
if app == 'playback':
config = get_config('%s' % uri)
if config is None:
continue
if os.path.isfile(config.file) and os.access(config.file, os.R_OK):
service = BonjourService(service='sipuri', name='Playback Test', uri_user=uri, is_focus=False)
service.start()
service.presence_state = BonjourPresenceState('available', u'File: %s' % os.path.basename(config.file))
self.bonjour_services.append(service)
def stop(self):
for service in self.bonjour_services:
service.stop()
del self.bonjour_services[:]
def incoming_session(self, session):
log.msg('Incoming session %s from %s to %s' % (session.call_id, session.remote_identity.uri, session.local_identity.uri))
config = get_config('%s@%s' % (session.request_uri.user, session.request_uri.host))
if config is None:
config = get_config('%s' % session.request_uri.user)
if config is None:
log.msg(u'Session %s rejected: no configuration found for %s' % (session.call_id, session.request_uri))
session.reject(488)
return
stream_types = {'audio'}
if config.enable_video:
stream_types.add('video')
streams = [stream for stream in session.proposed_streams if stream.type in stream_types]
if not streams:
log.msg(u'Session %s rejected: invalid media, only RTP audio and video is supported' % session.call_id)
session.reject(488)
return
handler = PlaybackHandler(config, session)
handler.run()
def incoming_subscription(self, request, data):
request.reject(405)
def incoming_referral(self, request, data):
request.reject(405)
def incoming_message(self, request, data):
request.reject(405)
class PlaybackHandler(object):
implements(IObserver)
def __init__(self, config, session):
self.config = config
self.session = session
self.proc = None
def run(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.session)
self.session.send_ring_indication()
stream_types = {'audio'}
if self.config.enable_video:
stream_types.add('video')
streams = [stream for stream in self.session.proposed_streams if stream.type in stream_types]
reactor.callLater(self.config.answer_delay, self._accept_session, self.session, streams)
def _accept_session(self, session, streams):
if session.state == 'incoming':
session.accept(streams)
def _play(self):
config = get_config('%s@%s' % (self.session.request_uri.user, self.session.request_uri.host))
if config is None:
config = get_config('%s' % self.session.request_uri.user)
try:
audio_stream = next(stream for stream in self.session.streams if stream.type=='audio')
except StopIteration:
self.proc = None
return
player = WavePlayer(audio_stream.mixer, config.file)
audio_stream.bridge.add(player)
log.msg(u"Playing file %s for session %s" % (config.file, self.session.call_id))
try:
player.play().wait()
except (ValueError, WavePlayerError), e:
log.warning(u"Error playing file %s: %s" % (config.file, e))
except proc.ProcExit:
pass
finally:
player.stop()
self.proc = None
audio_stream.bridge.remove(player)
self.session.end()
self.session = None
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionNewProposal(self, notification):
if notification.data.originator == 'remote':
session = notification.sender
stream_types = {'audio'}
if self.config.enable_video:
stream_types.add('video')
streams = [stream for stream in session.proposed_streams if stream.type in stream_types]
if not streams:
session.reject_proposal()
return
session.accept_proposal(streams)
def _NH_SIPSessionDidRenegotiateStreams(self, notification):
session = notification.sender
for stream in notification.data.added_streams:
log.msg('Session %s added %s' % (session.call_id, stream.type))
for stream in notification.data.removed_streams:
log.msg('Session %s removed %s' % (session.call_id, stream.type))
if notification.data.added_streams and self.proc is None:
self.proc = proc.spawn(self._play)
if notification.data.removed_streams and not session.streams:
session.end()
def _NH_SIPSessionDidStart(self, notification):
session = notification.sender
log.msg('Session %s started' % session.call_id)
self.proc = proc.spawn(self._play)
def _NH_SIPSessionDidFail(self, notification):
session = notification.sender
log.msg('Session %s failed' % session.call_id)
notification.center.remove_observer(self, sender=session)
def _NH_SIPSessionWillEnd(self, notification):
if self.proc:
self.proc.kill()
def _NH_SIPSessionDidEnd(self, notification):
session = notification.sender
log.msg('Session %s ended' % session.call_id)
notification.center.remove_observer(self, sender=session)
diff --git a/sylk/applications/playback/configuration.py b/sylk/applications/playback/configuration.py
index 0b96c64..88cc01e 100644
--- a/sylk/applications/playback/configuration.py
+++ b/sylk/applications/playback/configuration.py
@@ -1,48 +1,46 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
__all__ = ['get_config']
import os
from application.configuration import ConfigFile, ConfigSection, ConfigSetting
from sylk.configuration.datatypes import Path
from sylk.resources import Resources
class GeneralConfig(ConfigSection):
__cfgfile__ = 'playback.ini'
__section__ = 'Playback'
files_dir = ConfigSetting(type=Path, value=Path(Resources.get('sounds/playback')))
enable_video = False
answer_delay = 1
class PlaybackConfig(ConfigSection):
__cfgfile__ = 'playback.ini'
file = ConfigSetting(type=Path, value=None)
enable_video = GeneralConfig.enable_video
answer_delay = GeneralConfig.answer_delay
class Configuration(object):
def __init__(self, data):
self.__dict__.update(data)
def get_config(uri):
config_file = ConfigFile(PlaybackConfig.__cfgfile__)
GeneralConfig.read(cfgfile=config_file)
section = config_file.get_section(uri)
if section is not None:
PlaybackConfig.read(section=uri)
if not os.path.isabs(PlaybackConfig.file):
PlaybackConfig.file = os.path.join(GeneralConfig.files_dir, PlaybackConfig.file)
config = Configuration(dict(PlaybackConfig))
PlaybackConfig.reset()
return config
return None
diff --git a/sylk/applications/webrtcgateway/__init__.py b/sylk/applications/webrtcgateway/__init__.py
index 6429346..73cdf84 100644
--- a/sylk/applications/webrtcgateway/__init__.py
+++ b/sylk/applications/webrtcgateway/__init__.py
@@ -1,32 +1,30 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details
-#
from sylk.applications import SylkApplication
from sylk.applications.webrtcgateway.logger import log
from sylk.applications.webrtcgateway.util import IdentityFormatter
from sylk.applications.webrtcgateway.web import WebHandler
class WebRTCGatewayApplication(SylkApplication):
def __init__(self):
self.ws = WebHandler()
def start(self):
self.ws.start()
def stop(self):
self.ws.stop()
def incoming_session(self, session):
log.msg(u'New incoming session %s from %s rejected' % (session.call_id, IdentityFormatter.format(session.remote_identity)))
session.reject(403)
def incoming_subscription(self, request, data):
request.reject(405)
def incoming_referral(self, request, data):
request.reject(405)
def incoming_message(self, request, data):
request.reject(405)
diff --git a/sylk/applications/webrtcgateway/configuration.py b/sylk/applications/webrtcgateway/configuration.py
index 516926c..f558147 100644
--- a/sylk/applications/webrtcgateway/configuration.py
+++ b/sylk/applications/webrtcgateway/configuration.py
@@ -1,28 +1,26 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details
-#
from application.configuration import ConfigSection, ConfigSetting
from application.configuration.datatypes import StringList
from sylk.configuration.datatypes import SIPProxyAddress
class GeneralConfig(ConfigSection):
__cfgfile__ = 'webrtcgateway.ini'
__section__ = 'General'
web_origins = ConfigSetting(type=StringList, value=['*'])
sip_domains = ConfigSetting(type=StringList, value=['*'])
outbound_sip_proxy = ConfigSetting(type=SIPProxyAddress, value=None)
trace_websocket = False
websocket_ping_interval = 120
class JanusConfig(ConfigSection):
__cfgfile__ = 'webrtcgateway.ini'
__section__ = 'Janus'
api_url = 'ws://127.0.0.1:8188'
api_secret = '0745f2f74f34451c89343afcdcae5809'
trace_janus = False
diff --git a/sylk/applications/webrtcgateway/janus/__init__.py b/sylk/applications/webrtcgateway/janus/__init__.py
index 9303e2a..e69de29 100644
--- a/sylk/applications/webrtcgateway/janus/__init__.py
+++ b/sylk/applications/webrtcgateway/janus/__init__.py
@@ -1,3 +0,0 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details
-#
-
diff --git a/sylk/applications/webrtcgateway/janus/backend.py b/sylk/applications/webrtcgateway/janus/backend.py
index 8bae1ea..f0ecab9 100644
--- a/sylk/applications/webrtcgateway/janus/backend.py
+++ b/sylk/applications/webrtcgateway/janus/backend.py
@@ -1,266 +1,264 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details
-#
import functools
import json
import uuid
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.types import Singleton
from autobahn.twisted.websocket import connectWS, WebSocketClientFactory, WebSocketClientProtocol
from sipsimple.util import ISOTimestamp
from twisted.internet import reactor, defer
from twisted.internet.protocol import ReconnectingClientFactory
from twisted.python.failure import Failure
from zope.interface import implements
from sylk import __version__ as SYLK_VERSION
from sylk.applications.webrtcgateway.configuration import JanusConfig
from sylk.applications.webrtcgateway.janus.logger import Logger as JanusLogger
from sylk.applications.webrtcgateway.logger import log
class JanusRequest(object):
def __init__(self, request_type, **kwargs):
self.janus = request_type
self.transaction = uuid.uuid4().hex
if JanusConfig.api_secret:
self.apisecret = JanusConfig.api_secret
self.__dict__.update(**kwargs)
@property
def type(self):
return self.janus
@property
def transaction_id(self):
return self.transaction
def as_dict(self):
return self.__dict__.copy()
class JanusError(Exception):
def __init__(self, code, reason):
super(JanusError, self).__init__(reason)
self.code = code
self.reason = reason
class JanusClientProtocol(WebSocketClientProtocol):
_janus_event_handlers = None
_janus_pending_transactions = None
_janus_keepalive_timers = None
_janus_keepalive_timeout = 45
def onOpen(self):
notification_center = NotificationCenter()
notification_center.post_notification('JanusBackendConnected', sender=self)
self._janus_pending_transactions = {}
self._janus_keepalive_timers = {}
self._janus_event_handlers = {}
def onMessage(self, payload, isBinary):
if isBinary:
log.warn('Unexpected binary payload received')
return
if JanusConfig.trace_janus:
self.factory.janus_logger.msg("IN", ISOTimestamp.now(), payload)
try:
data = json.loads(payload)
except Exception, e:
log.warn('Error decoding payload: %s' % e)
return
try:
message_type = data.pop('janus')
except KeyError:
log.warn('Received payload lacks message type: %s' % payload)
return
transaction_id = data.pop('transaction', None)
if message_type == 'event' or transaction_id is None:
# This is an event. Janus is not very consistent here, some 'events'
# do have the transaction id set. So we check for the message type as well.
handle_id = data.pop('sender', -1)
handler = self._janus_event_handlers.get(handle_id, Null)
try:
handler(handle_id, message_type, data)
except Exception:
log.err()
return
try:
req, d = self._janus_pending_transactions.pop(transaction_id)
except KeyError:
log.warn('Discarding unexpected response: %s' % payload)
return
if message_type == 'error':
code = data['error']['code']
reason = data['error']['reason']
d.errback(JanusError(code, reason))
else:
if req.type == 'info':
result = data
elif req.type == 'create':
result = data['data']['id']
elif req.type == 'destroy':
result = None
elif req.type == 'attach':
result = data['data']['id']
elif req.type == 'detach':
result = None
elif req.type == 'keepalive':
result = None
elif req.type == 'ack':
result = None
else:
result = data
d.callback(result)
def connectionLost(self, reason):
super(JanusClientProtocol, self).connectionLost(reason)
notification_center = NotificationCenter()
notification_center.post_notification('JanusBackendDisconnected', sender=self, data=NotificationData(reason=reason.getErrorMessage()))
def disconnect(self, code=1000, reason=u''):
self.sendClose(code, reason)
def janus_set_event_handler(self, handle_id, event_handler):
if event_handler is None:
self._janus_event_handlers.pop(handle_id, None)
else:
assert callable(event_handler)
self._janus_event_handlers[handle_id] = event_handler
def _janus_send_request(self, req):
data = json.dumps(req.as_dict())
if JanusConfig.trace_janus:
self.factory.janus_logger.msg("OUT", ISOTimestamp.now(), data)
self.sendMessage(data)
d = defer.Deferred()
self._janus_pending_transactions[req.transaction_id] = (req, d)
return d
def janus_info(self):
req = JanusRequest('info')
return self._janus_send_request(req)
def janus_create_session(self):
req = JanusRequest('create')
return self._janus_send_request(req)
def janus_destroy_session(self, session_id):
req = JanusRequest('destroy', session_id=session_id)
return self._janus_send_request(req)
def janus_attach(self, session_id, plugin):
req = JanusRequest('attach', session_id=session_id, plugin=plugin)
return self._janus_send_request(req)
def janus_detach(self, session_id, handle_id):
req = JanusRequest('detach', session_id=session_id, handle_id=handle_id)
return self._janus_send_request(req)
def janus_message(self, session_id, handle_id, body, jsep=None):
req = JanusRequest('message', session_id=session_id, handle_id=handle_id, body=body)
if jsep is not None:
req.jsep = jsep
return self._janus_send_request(req)
def janus_trickle(self, session_id, handle_id, candidates):
req = JanusRequest('trickle', session_id=session_id, handle_id=handle_id)
if candidates:
if len(candidates) == 1:
req.candidate = candidates[0]
else:
req.candidates = candidates
else:
req.candidate = {'completed': True}
return self._janus_send_request(req)
def _janus_keepalive_cb(self, session_id, result):
if isinstance(result, Failure):
self.janus_stop_keepalive(session_id)
return
self._janus_keepalive_timers[session_id] = reactor.callLater(self._janus_keepalive_timeout, self._janus_send_keepalive, session_id)
def _janus_send_keepalive(self, session_id):
req = JanusRequest('keepalive', session_id=session_id)
d = self._janus_send_request(req)
d.addBoth(functools.partial(self._janus_keepalive_cb, session_id))
return d
def janus_start_keepalive(self, session_id):
self.janus_stop_keepalive(session_id)
self._janus_keepalive_timers[session_id] = reactor.callLater(self._janus_keepalive_timeout, self._janus_send_keepalive, session_id)
def janus_stop_keepalive(self, session_id):
timer = self._janus_keepalive_timers.pop(session_id, None)
if timer is not None and timer.active():
timer.cancel()
class JanusClientFactory(ReconnectingClientFactory, WebSocketClientFactory):
noisy = False
protocol = JanusClientProtocol
class JanusBackend(object):
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
self.janus_logger = JanusLogger()
self.factory = JanusClientFactory(url=JanusConfig.api_url,
protocols=['janus-protocol'],
useragent='SylkServer/%s' % SYLK_VERSION)
self.factory.janus_logger = self.janus_logger
self.connector = None
self.connection = Null
self._stopped = False
def __getattr__(self, attr):
if attr.startswith('janus_'):
return getattr(self.connection, attr)
return self.attr
@property
def ready(self):
return self.connection is not Null
def start(self):
self.janus_logger.start()
notification_center = NotificationCenter()
notification_center.add_observer(self, name='JanusBackendConnected')
notification_center.add_observer(self, name='JanusBackendDisconnected')
self.connector = connectWS(self.factory)
def stop(self):
if self._stopped:
return
self._stopped = True
self.janus_logger.stop()
self.factory.stopTrying()
notification_center = NotificationCenter()
notification_center.discard_observer(self, name='JanusBackendConnected')
notification_center.discard_observer(self, name='JanusBackendDisconnected')
if self.connector is not None:
self.connector.disconnect()
self.connector = None
if self.connection is not None:
self.connection.disconnect()
self.connection = Null
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_JanusBackendConnected(self, notification):
assert self.connection is Null
self.connection = notification.sender
log.msg('Janus backend connection up')
self.factory.resetDelay()
def _NH_JanusBackendDisconnected(self, notification):
log.msg('Janus backend connection down: %s' % notification.data.reason)
self.connection = Null
diff --git a/sylk/applications/webrtcgateway/janus/logger.py b/sylk/applications/webrtcgateway/janus/logger.py
index 67db9ba..ac5bb81 100644
--- a/sylk/applications/webrtcgateway/janus/logger.py
+++ b/sylk/applications/webrtcgateway/janus/logger.py
@@ -1,97 +1,95 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details.
-#
"""
Logging support for Janus traffic.
"""
__all__ = ["Logger"]
import os
import sys
from application.system import makedirs
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.threading import run_in_thread
class Logger(object):
def __init__(self):
self.stopped = False
self._janustrace_filename = None
self._janustrace_file = None
self._janustrace_error = False
self._janustrace_start_time = None
self._janustrace_packet_count = 0
self._log_directory_error = False
def start(self):
# try to create the log directory
try:
self._init_log_directory()
self._init_log_file()
except Exception:
pass
self.stopped = False
def stop(self):
self.stopped = True
if self._janustrace_file is not None:
self._janustrace_file.close()
self._janustrace_file = None
def msg(self, direction, timestamp, packet):
if self._janustrace_start_time is None:
self._janustrace_start_time = timestamp
self._janustrace_packet_count += 1
buf = ["%s: Packet %d, +%s" % (direction, self._janustrace_packet_count, (timestamp - self._janustrace_start_time))]
buf.append(packet)
buf.append('--')
message = '\n'.join(buf)
self._process_log((message, timestamp))
@run_in_thread('log-io')
def _process_log(self, record):
if self.stopped:
return
message, timestamp = record
try:
self._init_log_file()
except Exception:
pass
else:
self._janustrace_file.write('%s [%s %d]: %s\n' % (timestamp, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._janustrace_file.flush()
def _init_log_directory(self):
settings = SIPSimpleSettings()
log_directory = settings.logs.directory.normalized
try:
makedirs(log_directory)
except Exception, e:
if not self._log_directory_error:
print "failed to create logs directory '%s': %s" % (log_directory, e)
self._log_directory_error = True
self._janustrace_error = True
raise
else:
self._log_directory_error = False
if self._janustrace_filename is None:
self._janustrace_filename = os.path.join(log_directory, 'janus_trace.log')
self._janustrace_error = False
def _init_log_file(self):
if self._janustrace_file is None:
self._init_log_directory()
filename = self._janustrace_filename
try:
self._janustrace_file = open(filename, 'a')
except Exception, e:
if not self._janustrace_error:
print "failed to create log file '%s': %s" % (filename, e)
self._janustrace_error = True
raise
else:
self._janustrace_error = False
diff --git a/sylk/applications/webrtcgateway/logger.py b/sylk/applications/webrtcgateway/logger.py
index 1fc09c6..e2405c7 100644
--- a/sylk/applications/webrtcgateway/logger.py
+++ b/sylk/applications/webrtcgateway/logger.py
@@ -1,9 +1,7 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
__all__ = ['log']
from sylk.applications import ApplicationLogger
log = ApplicationLogger.for_package(__package__)
diff --git a/sylk/applications/webrtcgateway/util.py b/sylk/applications/webrtcgateway/util.py
index 3ce1a52..3ece6f0 100644
--- a/sylk/applications/webrtcgateway/util.py
+++ b/sylk/applications/webrtcgateway/util.py
@@ -1,34 +1,32 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details
-#
from eventlib.coros import event
class IdentityFormatter(object):
@classmethod
def format(cls, identity):
if identity.display_name:
return u'%s ' % (identity.display_name, identity.uri.user, identity.uri.host)
else:
return u'sip:%s@%s' % (identity.uri.user, identity.uri.host)
class GreenEvent(object):
def __init__(self):
self._event = event()
def set(self):
if self._event.ready():
return
self._event.send(True)
def is_set(self):
return self._event.ready()
def clear(self):
if self._event.ready():
self._event.reset()
def wait(self):
return self._event.wait()
diff --git a/sylk/applications/webrtcgateway/web/__init__.py b/sylk/applications/webrtcgateway/web/__init__.py
index 12bfb67..d3ad64e 100644
--- a/sylk/applications/webrtcgateway/web/__init__.py
+++ b/sylk/applications/webrtcgateway/web/__init__.py
@@ -1,93 +1,91 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details
-#
from application.python.types import Singleton
from autobahn.twisted.resource import WebSocketResource
from sylk import __version__ as sylk_version
from sylk.applications.webrtcgateway.configuration import GeneralConfig, JanusConfig
from sylk.applications.webrtcgateway.janus.backend import JanusBackend
from sylk.applications.webrtcgateway.logger import log
from sylk.applications.webrtcgateway.web.api import SYLK_WS_PROTOCOL, SylkWebSocketServerFactory
from sylk.applications.webrtcgateway.websocket_logger import Logger as WSLogger
from sylk.resources import Resources
from sylk.web import Klein, StaticFileResource, server
class WebRTCGatewayWeb(object):
__metaclass__ = Singleton
app = Klein()
_resource = None
_ws_resource = None
def __init__(self, ws_factory):
self._ws_resource = WebSocketResource(ws_factory)
def resource(self):
if self._resource is None:
self._resource = self.app.resource()
return self._resource
@app.route('/')
def index(self, request):
path = Resources.get('html/webrtcgateway/index.html')
r = StaticFileResource(path)
r.isLeaf = True
return r
@app.route('/ws')
def ws(self, request):
return self._ws_resource
@app.route('/js/', branch=True)
def js(self, request):
path = Resources.get('html/webrtcgateway/js/')
return StaticFileResource(path)
@app.route('/test/', branch=True)
def test(self, request):
path = Resources.get('html/webrtcgateway/test/')
return StaticFileResource(path)
class WebHandler(object):
def __init__(self):
self.backend = None
self.factory = None
self.resource = None
self.web = None
self.ws_logger = WSLogger()
def start(self):
ws_url = 'ws' + server.url[4:] + '/webrtcgateway/ws'
self.factory = SylkWebSocketServerFactory(ws_url, protocols=[SYLK_WS_PROTOCOL], server='SylkServer/%s' % sylk_version, debug=False)
self.factory.setProtocolOptions(allowedOrigins=GeneralConfig.web_origins,
autoPingInterval=GeneralConfig.websocket_ping_interval,
autoPingTimeout=GeneralConfig.websocket_ping_interval/2)
self.factory.ws_logger = self.ws_logger
self.web = WebRTCGatewayWeb(self.factory)
server.register_resource('webrtcgateway', self.web.resource())
log.msg('WebSocket handler started at %s' % ws_url)
log.msg('Allowed web origins: %s' % ', '.join(GeneralConfig.web_origins))
log.msg('Allowed SIP domains: %s' % ', '.join(GeneralConfig.sip_domains))
log.msg('Using Janus API: %s' % JanusConfig.api_url)
self.ws_logger.start()
self.backend = JanusBackend()
self.backend.start()
self.factory.backend = self.backend
def stop(self):
if self.factory is not None:
for conn in self.factory.connections.copy():
conn.failConnection()
self.factory = None
if self.backend is not None:
self.backend.stop()
self.backend = None
self.ws_logger.stop()
diff --git a/sylk/applications/webrtcgateway/web/api.py b/sylk/applications/webrtcgateway/web/api.py
index 88b310c..29a996d 100644
--- a/sylk/applications/webrtcgateway/web/api.py
+++ b/sylk/applications/webrtcgateway/web/api.py
@@ -1,783 +1,781 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details
-#
import json
import random
import re
import uuid
from application.python import Null
from application.notification import IObserver, NotificationCenter
from autobahn.twisted.websocket import WebSocketServerProtocol, WebSocketServerFactory
from autobahn.websocket import http
from eventlib import coros, proc
from eventlib.twistedutil import block_on
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import SIPURI, SIPCoreError
from sipsimple.lookup import DNSLookup, DNSLookupError
from sipsimple.threading.green import run_in_green_thread
from sipsimple.util import ISOTimestamp
from twisted.internet import reactor
from zope.interface import implements
from sylk.applications.webrtcgateway.configuration import GeneralConfig
from sylk.applications.webrtcgateway.logger import log
from sylk.applications.webrtcgateway.util import GreenEvent
SYLK_WS_PROTOCOL = 'sylkRTC-1'
SIP_PREFIX_RE = re.compile('^sips?:')
class AccountInfo(object):
def __init__(self, id, password):
self.id = id
self.password = password
self.registration_state = None
self.janus_handle_id = None
@property
def uri(self):
return 'sip:%s' % self.id
class SessionPartyIdentity(object):
def __init__(self, uri, display_name=''):
self.uri = uri
self.display_name = display_name
class SessionInfoBase(object):
type = None # override in subclass
def __init__(self, id):
self.id = id
self.direction = None
self.state = None
self.account_id = None
self.local_identity = None # instance of SessionPartyIdentity
self.remote_identity = None # instance of SessionPartyIdentity
def init_outgoing(self, account_id, destination):
self.account_id = account_id
self.direction = 'outgoing'
self.state = 'connecting'
self.local_identity = SessionPartyIdentity(account_id)
self.remote_identity = SessionPartyIdentity(destination)
def init_incoming(self, account_id, originator, originator_display_name=''):
self.account_id = account_id
self.direction = 'incoming'
self.state = 'connecting'
self.local_identity = SessionPartyIdentity(account_id)
self.remote_identity = SessionPartyIdentity(originator, originator_display_name)
class JanusSessionInfo(SessionInfoBase):
type = 'janus'
def __init__(self, id):
super(JanusSessionInfo, self).__init__(id)
self.janus_handle_id = None
class Operation(object):
__slots__ = ('name', 'data')
def __init__(self, name, data):
self.name = name
self.data = data
class APIError(Exception):
pass
class SylkWebSocketServerProtocol(WebSocketServerProtocol):
janus_session_id = None
accounts_map = None # account ID -> account
account_handles_map = None # Janus handle ID -> account
sessions_map = None # session ID -> session
session_handles_map = None # Janus handle ID -> session
ready_event = None
resolver = None
proc = None
operations_queue = None
def onConnect(self, request):
log.msg('Incoming connection from %s (origin %s)' % (request.peer, request.origin))
if SYLK_WS_PROTOCOL not in request.protocols:
log.msg('Rejecting connection, remote does not support our sub-protocol')
raise http.HttpException(http.NOT_ACCEPTABLE[0], 'No compatible protocol specified')
if not self.backend.ready:
log.msg('Rejecting connection, backend is not connected')
raise http.HttpException(http.SERVICE_UNAVAILABLE[0], 'Backend is not connected')
return SYLK_WS_PROTOCOL
def onOpen(self):
self.factory.connections.add(self)
self.accounts_map = {}
self.account_handles_map = {}
self.sessions_map = {}
self.session_handles_map = {}
self.ready_event = GreenEvent()
self.resolver = DNSLookup()
self.proc = proc.spawn(self._operations_handler)
self.operations_queue = coros.queue()
self._create_janus_session()
def onMessage(self, payload, isBinary):
if isBinary:
log.warn('Received invalid binary message')
return
if GeneralConfig.trace_websocket:
self.factory.ws_logger.msg("IN", ISOTimestamp.now(), payload)
try:
data = json.loads(payload)
except Exception, e:
log.warn('Error parsing WebSocket payload: %s' % e)
return
try:
request_type = data.pop('sylkrtc')
except KeyError:
log.warn('Error getting WebSocket message type')
return
self.ready_event.wait()
op = Operation(request_type.lower(), data)
self.operations_queue.send(op)
def onClose(self, wasClean, code, reason):
if self.ready_event is None:
# Very early connection closed, onOpen wasn't even called
return
log.msg('Connection from %s closed' % self.transport.getPeer())
self.factory.connections.discard(self)
if self.ready_event.is_set():
assert self.janus_session_id is not None
self.backend.janus_stop_keepalive(self.janus_session_id)
self.backend.janus_destroy_session(self.janus_session_id)
if self.proc is not None:
self.proc.kill()
self.proc = None
# cleanup
self.ready_event.clear()
self.accounts_map.clear()
self.account_handles_map.clear()
self.sessions_map.clear()
self.session_handles_map.clear()
self.janus_session_id = None
def disconnect(self, code=1000, reason=u''):
self.sendClose(code, reason)
# internal methods (not overriding / implementing the protocol API)
def _send_data(self, data):
if GeneralConfig.trace_websocket:
self.factory.ws_logger.msg("OUT", ISOTimestamp.now(), data)
self.sendMessage(data, False)
def _cleanup_session(self, session):
@run_in_green_thread
def do_cleanup():
if self.janus_session_id is None:
# The connection was closed, there is noting to do here
return
self.sessions_map.pop(session.id)
if session.direction == 'outgoing':
# Destroy plugin handle for outgoing sessions. For incoming ones it's the
# same as the account handle, so don't
block_on(self.backend.janus_detach(self.janus_session_id, session.janus_handle_id))
self.backend.janus_set_event_handler(session.janus_handle_id, None)
self.session_handles_map.pop(session.janus_handle_id)
# give it some time to receive other hangup events
reactor.callLater(2, do_cleanup)
@run_in_green_thread
def _create_janus_session(self):
if self.ready_event.is_set():
data = dict(sylkrtc='event', event='ready')
self._send_data(json.dumps(data))
return
try:
self.janus_session_id = block_on(self.backend.janus_create_session())
self.backend.janus_start_keepalive(self.janus_session_id)
except Exception, e:
log.warn('Error creating session, disconnecting: %s' % e)
self.disconnect(3000, unicode(e))
return
data = dict(sylkrtc='event', event='ready')
self._send_data(json.dumps(data))
self.ready_event.set()
def _lookup_sip_proxy(self, account):
sip_uri = SIPURI.parse('sip:%s' % account)
# The proxy dance: Sofia-SIP seems to do a DNS lookup per SIP message when a domain is passed
# as the proxy, so do the resolution ourselves and give it pre-resolver proxy URL. Since we use
# caching to avoid long delays, we randomize the results matching the highest priority route's
# transport.
proxy = GeneralConfig.outbound_sip_proxy
if proxy is not None:
proxy_uri = SIPURI(host=proxy.host,
port=proxy.port,
parameters={'transport': proxy.transport})
else:
proxy_uri = SIPURI(host=sip_uri.host)
settings = SIPSimpleSettings()
try:
routes = self.resolver.lookup_sip_proxy(proxy_uri, settings.sip.transport_list).wait()
except DNSLookupError, e:
raise DNSLookupError('DNS lookup error: %s' % e)
if not routes:
raise DNSLookupError('DNS lookup error: no results found')
# Get all routes with the highest priority transport and randomly pick one
route = random.choice([r for r in routes if r.transport==routes[0].transport])
# Build a proxy URI Sofia-SIP likes
return '%s:%s:%d%s' % ('sips' if route.transport=='tls' else 'sip',
route.address,
route.port,
';transport=%s' % route.transport if route.transport != 'tls' else '')
def _handle_janus_event(self, handle_id, event_type, event):
op = Operation('janus-event', data=dict(handle_id=handle_id, event_type=event_type, event=event))
self.operations_queue.send(op)
def _operations_handler(self):
while True:
op = self.operations_queue.wait()
handler = getattr(self, '_OH_%s' % op.name.replace('-', '_'), Null)
try:
handler(op.data)
except Exception:
log.err()
del op
del handler
def _OH_account_add(self, data):
transaction = data.get('transaction', None)
if transaction is None:
log.warn('Transaction not specified!')
return
try:
try:
account = data['account']
password = data['password']
except KeyError:
raise APIError('Invalid parameters: "account" and "password" must be specified')
if account in self.accounts_map:
log.warn('Account %s already added' % account)
data = dict(sylkrtc='error', transaction=transaction, error='Account already added')
self._send_data(json.dumps(data))
return
# Validate URI
uri = 'sip:%s' % account
try:
sip_uri = SIPURI.parse(uri)
except SIPCoreError:
raise APIError('Invalid account specified: %s' % account)
if not {'*', sip_uri.host}.intersection(GeneralConfig.sip_domains):
raise APIError('SIP domain not allowed: %s' % sip_uri.host)
# Create and store our mapping
account_info = AccountInfo(account, password)
self.accounts_map[account_info.id] = account_info
data = dict(sylkrtc='ack', transaction=transaction)
self._send_data(json.dumps(data))
log.msg('Account %s added' % account)
except APIError, e:
log.error('account_add: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
except Exception, e:
log.error('Unexpected error in account_add: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
def _OH_account_remove(self, data):
transaction = data.get('transaction', None)
if transaction is None:
log.warn('Transaction not specified!')
return
try:
try:
account = data['account']
except KeyError:
raise APIError('Invalid parameters: "account" must be specified')
try:
account_info = self.accounts_map.pop(account)
except KeyError:
raise APIError('Unknown account specified: %s' % account)
handle_id = account_info.janus_handle_id
if handle_id is not None:
block_on(self.backend.janus_detach(self.janus_session_id, handle_id))
self.backend.janus_set_event_handler(handle_id, None)
self.account_handles_map.pop(handle_id)
data = dict(sylkrtc='ack', transaction=transaction)
self._send_data(json.dumps(data))
log.msg('Account %s removed' % account)
except APIError, e:
log.error('account_remove: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
except Exception, e:
log.error('Unexpected error in account_remove: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
def _OH_account_register(self, data):
transaction = data.get('transaction', None)
if transaction is None:
log.warn('Transaction not specified!')
return
try:
try:
account = data['account']
except KeyError:
raise APIError('Invalid parameters: "account" must be specified')
try:
account_info = self.accounts_map[account]
except KeyError:
raise APIError('Unknown account specified: %s' % account)
proxy = self._lookup_sip_proxy(account)
handle_id = account_info.janus_handle_id
if handle_id is not None:
# Destroy the existing plugin handle
block_on(self.backend.janus_detach(self.janus_session_id, handle_id))
self.backend.janus_set_event_handler(handle_id, None)
self.account_handles_map.pop(handle_id)
account_info.janus_handle_id = None
# Create a plugin handle
handle_id = block_on(self.backend.janus_attach(self.janus_session_id, 'janus.plugin.sip'))
self.backend.janus_set_event_handler(handle_id, self._handle_janus_event)
account_info.janus_handle_id = handle_id
self.account_handles_map[handle_id] = account_info
data = {'request': 'register',
'username': account_info.uri,
'ha1_secret': account_info.password,
'proxy': proxy}
block_on(self.backend.janus_message(self.janus_session_id, handle_id, data))
data = dict(sylkrtc='ack', transaction=transaction)
self._send_data(json.dumps(data))
log.msg('Account %s will register' % account)
except APIError, e:
log.error('account-register: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
except Exception, e:
log.error('Unexpected error in account-register: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
def _OH_account_unregister(self, data):
transaction = data.get('transaction', None)
if transaction is None:
log.warn('Transaction not specified!')
return
try:
try:
account = data['account']
except KeyError:
raise APIError('Invalid parameters: "account" must be specified')
try:
account_info = self.accounts_map[account]
except KeyError:
raise APIError('Unknown account specified: %s' % account)
handle_id = account_info.janus_handle_id
if handle_id is not None:
block_on(self.backend.janus_detach(self.janus_session_id, handle_id))
self.backend.janus_set_event_handler(handle_id, None)
account_info.janus_handle_id = None
self.account_handles_map.pop(handle_id)
data = dict(sylkrtc='ack', transaction=transaction)
self._send_data(json.dumps(data))
log.msg('Account %s will unregister' % account)
except APIError, e:
log.error('account-unregister: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
except Exception, e:
log.error('Unexpected error in account-unregister: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
def _OH_session_create(self, data):
transaction = data.get('transaction', None)
if transaction is None:
log.warn('Transaction not specified!')
return
try:
try:
account = data['account']
session = data['session']
uri = data['uri']
sdp = data['sdp']
except KeyError:
raise APIError('Invalid parameters: "account", "session", "uri" and "sdp" must be specified')
try:
account_info = self.accounts_map[account]
except KeyError:
raise APIError('Unknown account specified: %s' % account)
if session in self.sessions_map:
raise APIError('Session ID (%s) already in use' % session)
# Create a new plugin handle and 'register' it, without actually doing so
handle_id = block_on(self.backend.janus_attach(self.janus_session_id, 'janus.plugin.sip'))
self.backend.janus_set_event_handler(handle_id, self._handle_janus_event)
try:
proxy = self._lookup_sip_proxy(account_info.id)
except DNSLookupError:
block_on(self.backend.janus_detach(self.janus_session_id, handle_id))
self.backend.janus_set_event_handler(handle_id, None)
raise APIError('DNS lookup error')
account_uri = 'sip:%s' % account_info.id
data = {'request': 'register', 'username': account_uri, 'ha1_secret': account_info.password, 'proxy': proxy, 'send_register': False}
block_on(self.backend.janus_message(self.janus_session_id, handle_id, data))
session_info = JanusSessionInfo(session)
session_info.janus_handle_id = handle_id
session_info.init_outgoing(account, uri)
self.sessions_map[session_info.id] = session_info
self.session_handles_map[handle_id] = session_info
data = {'request': 'call', 'uri': 'sip:%s' % SIP_PREFIX_RE.sub('', uri)}
jsep = {'type': 'offer', 'sdp': sdp}
block_on(self.backend.janus_message(self.janus_session_id, handle_id, data, jsep))
data = dict(sylkrtc='ack', transaction=transaction)
self._send_data(json.dumps(data))
log.msg('Outgoing session %s from %s to %s created' % (session, account, uri))
except APIError, e:
log.error('session-create: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
except Exception, e:
log.error('Unexpected error in session-create: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
def _OH_session_answer(self, data):
transaction = data.get('transaction', None)
if transaction is None:
log.warn('Transaction not specified!')
return
try:
try:
session = data['session']
sdp = data['sdp']
except KeyError:
raise APIError('Invalid parameters: "session" and "sdp" must be specified')
try:
session_info = self.sessions_map[session]
except KeyError:
raise APIError('Unknown session specified: %s' % session)
if session_info.direction != 'incoming':
raise APIError('Cannot answer outgoing session')
if session_info.state != 'connecting':
raise APIError('Invalid state for session answer')
data = {'request': 'accept'}
jsep = {'type': 'answer', 'sdp': sdp}
block_on(self.backend.janus_message(self.janus_session_id, session_info.janus_handle_id, data, jsep))
data = dict(sylkrtc='ack', transaction=transaction)
self._send_data(json.dumps(data))
log.msg('%s answered session %s' % (session_info.account_id, session))
except APIError, e:
log.error('session-answer: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
except Exception, e:
log.error('Unexpected error in session-answer: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
def _OH_session_trickle(self, data):
transaction = data.get('transaction', None)
if transaction is None:
log.warn('Transaction not specified!')
return
try:
try:
session = data['session']
candidates = data['candidates']
except KeyError:
raise APIError('Invalid parameters: "session" and "candidates" must be specified')
try:
session_info = self.sessions_map[session]
except KeyError:
raise APIError('Unknown session specified: %s' % session)
if session_info.state == 'terminated':
raise APIError('Session is terminated')
block_on(self.backend.janus_trickle(self.janus_session_id, session_info.janus_handle_id, candidates))
data = dict(sylkrtc='ack', transaction=transaction)
self._send_data(json.dumps(data))
log.msg('Trickled ICE candidate(s) for session %s' % session)
except APIError, e:
log.error('session-trickle: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
except Exception, e:
log.error('Unexpected error in session-trickle: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
def _OH_session_terminate(self, data):
transaction = data.get('transaction', None)
if transaction is None:
log.warn('Transaction not specified!')
return
try:
try:
session = data['session']
except KeyError:
raise APIError('Invalid parameters: "session" must be specified')
try:
session_info = self.sessions_map[session]
except KeyError:
raise APIError('Unknown session specified: %s' % session)
if session_info.state not in ('connecting', 'progress', 'accepted', 'established'):
raise APIError('Invalid state for session terminate: \"%s\"' % session_info.state)
if session_info.direction == 'incoming' and session_info.state == 'connecting':
data = {'request': 'decline', 'code': 486}
else:
data = {'request': 'hangup'}
block_on(self.backend.janus_message(self.janus_session_id, session_info.janus_handle_id, data))
data = dict(sylkrtc='ack', transaction=transaction)
self._send_data(json.dumps(data))
log.msg('%s terminated session %s' % (session_info.account_id, session))
except APIError, e:
log.error('session-terminate: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
except Exception, e:
log.error('Unexpected error in session-terminate: %s' % e)
data = dict(sylkrtc='error', transaction=transaction, error=str(e))
self._send_data(json.dumps(data))
# Event handlers
def _OH_janus_event(self, data):
handle_id = data['handle_id']
event_type = data['event_type']
event = data['event']
if event_type == 'event':
event_data = event['plugindata']['data']
if 'result' in event_data:
jsep = event.get('jsep', None)
event_type = event_data['result']['event']
if event_type in ('registering', 'registered', 'registration_failed', 'incomingcall'):
# skip 'registered' events from session handles
if event_type == 'registered' and event_data['result']['register_sent'] in (False, 'false'):
return
# account event
try:
account_info = self.account_handles_map[handle_id]
except KeyError:
log.warn('Could not find account for handle ID %s' % handle_id)
return
if event_type == 'incomingcall':
originator_uri = SIP_PREFIX_RE.sub('', event_data['result']['username'])
originator_display_name = event_data['result'].get('displayname', '').replace('"', '')
jsep = event.get('jsep', None)
assert jsep is not None
session_id = uuid.uuid4().hex
session = JanusSessionInfo(session_id)
session.janus_handle_id = handle_id
session.init_incoming(account_info.id, originator_uri, originator_display_name)
self.sessions_map[session_id] = session
self.session_handles_map[handle_id] = session
data = dict(sylkrtc='account_event',
account=account_info.id,
session=session_id,
event='incoming_session',
data=dict(originator=session.remote_identity.__dict__, sdp=jsep['sdp']))
log.msg('Incoming session %s %s <-> %s created' % (session.id,
session.remote_identity.uri,
session.local_identity.uri))
else:
registration_state = event_type
if registration_state == 'registration_failed':
registration_state = 'failed'
if account_info.registration_state == registration_state:
return
account_info.registration_state = registration_state
registration_data = dict(state=registration_state)
if registration_state == 'failed':
code = event_data['result']['code']
reason = event_data['result']['reason']
registration_data['reason'] = '%d %s' % (code, reason)
data = dict(sylkrtc='account_event',
account=account_info.id,
event='registration_state',
data=registration_data)
log.msg('Account %s registration state changed to %s' % (account_info.id, registration_state))
self._send_data(json.dumps(data))
elif event_type in ('calling', 'accepted', 'hangup'):
# session event
try:
session_info = self.session_handles_map[handle_id]
except KeyError:
log.warn('Could not find session for handle ID %s' % handle_id)
return
if event_type == 'hangup' and session_info.state == 'terminated':
return
if event_type == 'calling':
session_info.state = 'progress'
elif event_type == 'accepted':
session_info.state = 'accepted'
elif event_type == 'hangup':
session_info.state = 'terminated'
data = dict(sylkrtc='session_event',
session=session_info.id,
event='state',
data=dict(state=session_info.state))
log.msg('%s session %s state: %s' % (session_info.direction.title(), session_info.id, session_info.state))
if session_info.state == 'accepted' and session_info.direction == 'outgoing':
assert jsep is not None
data['data']['sdp'] = jsep['sdp']
elif session_info.state == 'terminated':
code = event_data['result'].get('code', 0)
reason = event_data['result'].get('reason', 'Unknown')
reason = '%d %s' % (code, reason)
data['data']['reason'] = reason
self._send_data(json.dumps(data))
if session_info.state == 'terminated':
self._cleanup_session(session_info)
log.msg('%s session %s %s <-> %s terminated (%s)' % (session_info.direction.title(),
session_info.id,
session_info.local_identity.uri,
session_info.remote_identity.uri,
reason))
# check if missed incoming call
if session_info.direction == 'incoming' and code == 487:
data = dict(sylkrtc='account_event',
account=session_info.account_id,
event='missed_session',
data=dict(originator=session_info.remote_identity.__dict__))
log.msg('Incoming session from %s missed' % session_info.remote_identity.uri)
self._send_data(json.dumps(data))
elif event_type == 'missed_call':
try:
account_info = self.account_handles_map[handle_id]
except KeyError:
log.warn('Could not find account for handle ID %s' % handle_id)
return
originator_uri = SIP_PREFIX_RE.sub('', event_data['result']['caller'])
originator_display_name = event_data['result'].get('displayname', '').replace('"', '')
# We have no session, so create an identity object by hand
originator = SessionPartyIdentity(originator_uri, originator_display_name)
data = dict(sylkrtc='account_event',
account=account_info.id,
event='missed_session',
data=dict(originator=originator.__dict__))
log.msg('Incoming session from %s missed' % originator.uri)
self._send_data(json.dumps(data))
elif event_type in ('ack', 'declining', 'hangingup'):
# ignore
pass
else:
log.warn('Unexpected SIP plugin event type: %s' % event_type)
else:
log.warn('Unexpected event: %s' % event)
elif event_type == 'webrtcup':
try:
session_info = self.session_handles_map[handle_id]
except KeyError:
log.msg('Could not find session for handle ID %s' % handle_id)
return
session_info.state = 'established'
data = dict(sylkrtc='session_event',
session=session_info.id,
event='state',
data=dict(state=session_info.state))
log.msg('%s session %s state: %s' % (session_info.direction.title(), session_info.id, session_info.state))
self._send_data(json.dumps(data))
elif event_type == 'hangup':
try:
session_info = self.session_handles_map[handle_id]
except KeyError:
log.msg('Could not find session for handle ID %s' % handle_id)
return
if session_info.state != 'terminated':
session_info.state = 'terminated'
code = event.get('code', 0)
reason = event.get('reason', 'Unknown')
reason = '%d %s' % (code, reason)
data = dict(sylkrtc='session_event',
session=session_info.id,
event='state',
data=dict(state=session_info.state, reason=reason))
log.msg('%s session %s state: %s' % (session_info.direction.title(), session_info.id, session_info.state))
self._send_data(json.dumps(data))
self._cleanup_session(session_info)
log.msg('%s session %s %s <-> %s terminated (%s)' % (session_info.direction.title(),
session_info.id,
session_info.local_identity.uri,
session_info.remote_identity.uri,
reason))
elif event_type in ('media', 'detached'):
# ignore
pass
else:
log.warn('Received unexpected event type: %s' % event_type)
class SylkWebSocketServerFactory(WebSocketServerFactory):
implements(IObserver)
protocol = SylkWebSocketServerProtocol
connections = set()
backend = None # assigned by WebHandler
def __init__(self, *args, **kw):
super(SylkWebSocketServerFactory, self).__init__(*args, **kw)
notification_center = NotificationCenter()
notification_center.add_observer(self, name='JanusBackendDisconnected')
def buildProtocol(self, addr):
protocol = self.protocol()
protocol.factory = self
protocol.backend = self.backend
return protocol
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_JanusBackendDisconnected(self, notification):
for conn in self.connections.copy():
conn.failConnection()
diff --git a/sylk/applications/webrtcgateway/websocket_logger.py b/sylk/applications/webrtcgateway/websocket_logger.py
index d12cc95..bc0e5c5 100644
--- a/sylk/applications/webrtcgateway/websocket_logger.py
+++ b/sylk/applications/webrtcgateway/websocket_logger.py
@@ -1,97 +1,95 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details.
-#
"""
Logging support for WebSocket traffic.
"""
__all__ = ["Logger"]
import os
import sys
from application.system import makedirs
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.threading import run_in_thread
class Logger(object):
def __init__(self):
self.stopped = False
self._wstrace_filename = None
self._wstrace_file = None
self._wstrace_error = False
self._wstrace_start_time = None
self._wstrace_packet_count = 0
self._log_directory_error = False
def start(self):
# try to create the log directory
try:
self._init_log_directory()
self._init_log_file()
except Exception:
pass
self.stopped = False
def stop(self):
self.stopped = True
if self._wstrace_file is not None:
self._wstrace_file.close()
self._wstrace_file = None
def msg(self, direction, timestamp, packet):
if self._wstrace_start_time is None:
self._wstrace_start_time = timestamp
self._wstrace_packet_count += 1
buf = ["%s: Packet %d, +%s" % (direction, self._wstrace_packet_count, (timestamp - self._wstrace_start_time))]
buf.append(packet)
buf.append('--')
message = '\n'.join(buf)
self._process_log((message, timestamp))
@run_in_thread('log-io')
def _process_log(self, record):
if self.stopped:
return
message, timestamp = record
try:
self._init_log_file()
except Exception:
pass
else:
self._wstrace_file.write('%s [%s %d]: %s\n' % (timestamp, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._wstrace_file.flush()
def _init_log_directory(self):
settings = SIPSimpleSettings()
log_directory = settings.logs.directory.normalized
try:
makedirs(log_directory)
except Exception, e:
if not self._log_directory_error:
print "failed to create logs directory '%s': %s" % (log_directory, e)
self._log_directory_error = True
self._wstrace_error = True
raise
else:
self._log_directory_error = False
if self._wstrace_filename is None:
self._wstrace_filename = os.path.join(log_directory, 'webrtcgateway_trace.log')
self._wstrace_error = False
def _init_log_file(self):
if self._wstrace_file is None:
self._init_log_directory()
filename = self._wstrace_filename
try:
self._wstrace_file = open(filename, 'a')
except Exception, e:
if not self._wstrace_error:
print "failed to create log file '%s': %s" % (filename, e)
self._wstrace_error = True
raise
else:
self._wstrace_error = False
diff --git a/sylk/applications/xmppgateway/__init__.py b/sylk/applications/xmppgateway/__init__.py
index 2bc0aac..0cde075 100644
--- a/sylk/applications/xmppgateway/__init__.py
+++ b/sylk/applications/xmppgateway/__init__.py
@@ -1,556 +1,554 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
from application.notification import IObserver, NotificationCenter
from application.python import Null
from sipsimple.core import SIPURI, SIPCoreError
from sipsimple.payloads import ParserError
from sipsimple.payloads.iscomposing import IsComposingDocument, IsComposingMessage
from sipsimple.streams.msrp.chat import CPIMPayload, CPIMParserError
from sipsimple.threading.green import run_in_green_thread
from zope.interface import implements
from sylk.applications import SylkApplication
from sylk.applications.xmppgateway.configuration import XMPPGatewayConfig
from sylk.applications.xmppgateway.datatypes import Identity, FrozenURI, generate_sylk_resource, decode_resource
from sylk.applications.xmppgateway.im import SIPMessageSender, SIPMessageError, ChatSessionHandler
from sylk.applications.xmppgateway.logger import log
from sylk.applications.xmppgateway.presence import S2XPresenceHandler, X2SPresenceHandler
from sylk.applications.xmppgateway.media import MediaSessionHandler
from sylk.applications.xmppgateway.muc import X2SMucInvitationHandler, S2XMucInvitationHandler, X2SMucHandler
from sylk.applications.xmppgateway.util import format_uri
from sylk.applications.xmppgateway.xmpp import XMPPManager
from sylk.applications.xmppgateway.xmpp.session import XMPPChatSession
from sylk.applications.xmppgateway.xmpp.stanzas import ChatMessage, ChatComposingIndication, NormalMessage
class XMPPGatewayApplication(SylkApplication):
implements(IObserver)
def __init__(self):
self.xmpp_manager = XMPPManager()
self.pending_sessions = {}
self.chat_sessions = set()
self.media_sessions = set()
self.s2x_muc_sessions = {}
self.x2s_muc_sessions = {}
self.s2x_presence_subscriptions = {}
self.x2s_presence_subscriptions = {}
self.s2x_muc_add_participant_handlers = {}
self.x2s_muc_add_participant_handlers = {}
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.xmpp_manager)
notification_center.add_observer(self, name='JingleSessionNewIncoming')
self.xmpp_manager.start()
def stop(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=self.xmpp_manager)
notification_center.add_observer(self, name='JingleSessionNewIncoming')
self.xmpp_manager.stop()
def incoming_session(self, session):
stream_types = set([stream.type for stream in session.proposed_streams])
if 'chat' in stream_types:
log.msg('New chat session from %s to %s' % (session.remote_identity.uri, session.local_identity.uri))
self.incoming_chat_session(session)
elif 'audio' in stream_types:
log.msg('New audio session from %s to %s' % (session.remote_identity.uri, session.local_identity.uri))
self.incoming_media_session(session)
else:
log.msg('New session from %s to %s rejected. Unsupported media: %s ' % (session.remote_identity.uri, session.local_identity.uri, stream_types))
session.reject(488)
def incoming_chat_session(self, session):
# Check if this session is really an invitation to add a participant to a conference room / muc
if session.remote_identity.uri.host in self.xmpp_manager.muc_domains and 'isfocus' in session._invitation.remote_contact_header.parameters:
try:
referred_by_uri = SIPURI.parse(session.transfer_info.referred_by)
except SIPCoreError:
log.msg("SIP multiparty session invitation %s failed: invalid Referred-By header" % session.call_id)
session.reject(488)
return
muc_uri = FrozenURI(session.remote_identity.uri.user, session.remote_identity.uri.host)
inviter_uri = FrozenURI(referred_by_uri.user, referred_by_uri.host)
recipient_uri = FrozenURI(session.local_identity.uri.user, session.local_identity.uri.host)
sender = Identity(muc_uri)
recipient = Identity(recipient_uri)
inviter = Identity(inviter_uri)
try:
handler = self.s2x_muc_add_participant_handlers[(muc_uri, recipient_uri)]
except KeyError:
handler = S2XMucInvitationHandler(session, sender, recipient, inviter)
self.s2x_muc_add_participant_handlers[(muc_uri, recipient_uri)] = handler
NotificationCenter().add_observer(self, sender=handler)
handler.start()
else:
log.msg("SIP multiparty session invitation %s failed: there is another invitation in progress from %s to %s" % (session.call_id,
format_uri(inviter_uri, 'sip'),
format_uri(recipient_uri, 'xmpp')))
session.reject(480)
return
# Check domain
if session.remote_identity.uri.host not in XMPPGatewayConfig.domains:
log.msg('Session rejected: From domain is not a local XMPP domain')
session.reject(606, 'Not Acceptable')
return
# Get URI representing the SIP side
contact_uri = session._invitation.remote_contact_header.uri
if contact_uri.parameters.get('gr') is not None:
sip_leg_uri = FrozenURI(contact_uri.user, contact_uri.host, contact_uri.parameters.get('gr'))
else:
tmp = session.remote_identity.uri
sip_leg_uri = FrozenURI(tmp.user, tmp.host, generate_sylk_resource())
# Get URI representing the XMPP side
request_uri = session.request_uri
remote_resource = request_uri.parameters.get('gr', None)
if remote_resource is not None:
try:
remote_resource = decode_resource(remote_resource)
except (TypeError, UnicodeError):
remote_resource = None
xmpp_leg_uri = FrozenURI(request_uri.user, request_uri.host, remote_resource)
try:
handler = self.pending_sessions[(sip_leg_uri, xmpp_leg_uri)]
except KeyError:
pass
else:
# There is another pending session with same identifiers, can't accept this one
log.msg('Session rejected: other session with same identifiers in progress')
session.reject(488)
return
sip_identity = Identity(sip_leg_uri, session.remote_identity.display_name)
handler = ChatSessionHandler.new_from_sip_session(sip_identity, session)
NotificationCenter().add_observer(self, sender=handler)
key = (sip_leg_uri, xmpp_leg_uri)
self.pending_sessions[key] = handler
if xmpp_leg_uri.resource is not None:
# Incoming session target contained GRUU, so create XMPPChatSession immediately
xmpp_session = XMPPChatSession(local_identity=handler.sip_identity, remote_identity=Identity(xmpp_leg_uri))
handler.xmpp_identity = xmpp_session.remote_identity
handler.xmpp_session = xmpp_session
def incoming_media_session(self, session):
if session.remote_identity.uri.host not in self.xmpp_manager.domains|self.xmpp_manager.muc_domains:
log.msg('Session rejected: From domain is not a local XMPP domain')
session.reject(403)
return
handler = MediaSessionHandler.new_from_sip_session(session)
if handler is not None:
NotificationCenter().add_observer(self, sender=handler)
def incoming_subscription(self, subscribe_request, data):
from_header = data.headers.get('From', Null)
to_header = data.headers.get('To', Null)
if Null in (from_header, to_header):
subscribe_request.reject(400)
return
if XMPPGatewayConfig.log_presence:
log.msg('SIP subscription from %s to %s' % (format_uri(from_header.uri, 'sip'), format_uri(to_header.uri, 'xmpp')))
if subscribe_request.event != 'presence':
if XMPPGatewayConfig.log_presence:
log.msg('SIP subscription rejected: only presence event is supported')
subscribe_request.reject(489)
return
# Check domain
remote_identity_uri = data.headers['From'].uri
if remote_identity_uri.host not in XMPPGatewayConfig.domains:
if XMPPGatewayConfig.log_presence:
log.msg('SIP subscription rejected: From domain is not a local XMPP domain')
subscribe_request.reject(606)
return
# Get URI representing the SIP side
sip_leg_uri = FrozenURI(remote_identity_uri.user, remote_identity_uri.host)
# Get URI representing the XMPP side
request_uri = data.request_uri
xmpp_leg_uri = FrozenURI(request_uri.user, request_uri.host)
try:
handler = self.s2x_presence_subscriptions[(sip_leg_uri, xmpp_leg_uri)]
except KeyError:
sip_identity = Identity(sip_leg_uri, data.headers['From'].display_name)
xmpp_identity = Identity(xmpp_leg_uri)
handler = S2XPresenceHandler(sip_identity, xmpp_identity)
self.s2x_presence_subscriptions[(sip_leg_uri, xmpp_leg_uri)] = handler
NotificationCenter().add_observer(self, sender=handler)
handler.start()
handler.add_sip_subscription(subscribe_request)
def incoming_referral(self, refer_request, data):
refer_request.reject(405)
def incoming_message(self, message_request, data):
content_type = data.headers.get('Content-Type', Null).content_type
from_header = data.headers.get('From', Null)
to_header = data.headers.get('To', Null)
if Null in (content_type, from_header, to_header):
message_request.answer(400)
return
log.msg('New SIP Message from %s to %s' % (from_header.uri, to_header.uri))
# Check domain
if from_header.uri.host not in XMPPGatewayConfig.domains:
log.msg('Message rejected: From domain is not a local XMPP domain')
message_request.answer(606)
return
if content_type == 'message/cpim':
try:
cpim_message = CPIMPayload.decode(data.body)
except CPIMParserError:
log.msg('Message rejected: CPIM parse error')
message_request.answer(400)
return
else:
body = cpim_message.content
content_type = cpim_message.content_type
sender = cpim_message.sender or from_header
from_uri = sender.uri
else:
body = data.body
from_uri = from_header.uri
to_uri = str(to_header.uri)
message_request.answer(200)
if from_uri.parameters.get('gr', None) is None:
from_uri = SIPURI.new(from_uri)
from_uri.parameters['gr'] = generate_sylk_resource()
sender = Identity(FrozenURI.parse(from_uri))
recipient = Identity(FrozenURI.parse(to_uri))
if content_type in ('text/plain', 'text/html'):
if content_type == 'text/plain':
html_body = None
else:
html_body = body
body = None
if XMPPGatewayConfig.use_msrp_for_chat:
message = NormalMessage(sender, recipient, body, html_body, use_receipt=False)
self.xmpp_manager.send_stanza(message)
else:
message = ChatMessage(sender, recipient, body, html_body, use_receipt=False)
self.xmpp_manager.send_stanza(message)
elif content_type == IsComposingDocument.content_type:
if not XMPPGatewayConfig.use_msrp_for_chat:
try:
msg = IsComposingMessage.parse(body)
except ParserError:
pass
else:
state = 'composing' if msg.state == 'active' else 'paused'
message = ChatComposingIndication(sender, recipient, state, use_receipt=False)
self.xmpp_manager.send_stanza(message)
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
# Out of band XMPP stanza handling
@run_in_green_thread
def _NH_XMPPGotChatMessage(self, notification):
# This notification is only processed here untill the ChatSessionHandler
# has both (SIP and XMPP) sessions established
message = notification.data.message
sender = message.sender
recipient = message.recipient
if XMPPGatewayConfig.use_msrp_for_chat:
if recipient.uri.resource is None:
# If recipient resource is not set the session is started from
# the XMPP side
sip_leg_uri = FrozenURI.new(recipient.uri)
xmpp_leg_uri = FrozenURI.new(sender.uri)
try:
handler = self.pending_sessions[(sip_leg_uri, xmpp_leg_uri)]
handler.enqueue_xmpp_message(message)
except KeyError:
# Check if we have any already open chat session and dispatch it there
try:
handler = next(h for h in self.chat_sessions if h.xmpp_identity.uri.user == xmpp_leg_uri.user and h.xmpp_identity.uri.host == xmpp_leg_uri.host and h.sip_identity.uri.user == sip_leg_uri.user and h.sip_identity.uri.host == sip_leg_uri.host)
except StopIteration:
# Not found, need to create a new handler and a outgoing SIP session
xmpp_identity = Identity(xmpp_leg_uri)
handler = ChatSessionHandler.new_from_xmpp_stanza(xmpp_identity, sip_leg_uri)
key = (sip_leg_uri, xmpp_leg_uri)
self.pending_sessions[key] = handler
NotificationCenter().add_observer(self, sender=handler)
handler.enqueue_xmpp_message(message)
else:
# Find handler pending XMPP confirmation
sip_leg_uri = FrozenURI.new(recipient.uri)
xmpp_leg_uri = FrozenURI(sender.uri.user, sender.uri.host)
try:
handler = self.pending_sessions[(sip_leg_uri, xmpp_leg_uri)]
except KeyError:
# Find handler pending XMPP confirmation
sip_leg_uri = FrozenURI(recipient.uri.user, recipient.uri.host)
xmpp_leg_uri = FrozenURI.new(sender.uri)
try:
handler = self.pending_sessions[(sip_leg_uri, xmpp_leg_uri)]
except KeyError:
# Try harder, maybe the XMPP client changed his from
try:
handler = next(h for h in self.chat_sessions if h.xmpp_identity.uri.user == xmpp_leg_uri.user and h.xmpp_identity.uri.host == xmpp_leg_uri.host and h.sip_identity.uri.user == sip_leg_uri.user and h.sip_identity.uri.host == sip_leg_uri.host)
except StopIteration:
# It's a new XMPP session to a full JID, disregard the full JID and start a new SIP session to the bare JID
xmpp_identity = Identity(xmpp_leg_uri)
handler = ChatSessionHandler.new_from_xmpp_stanza(xmpp_identity, sip_leg_uri)
key = (sip_leg_uri, xmpp_leg_uri)
self.pending_sessions[key] = handler
NotificationCenter().add_observer(self, sender=handler)
handler.enqueue_xmpp_message(message)
else:
# Found handle, create XMPP session and establish session
session = XMPPChatSession(local_identity=recipient, remote_identity=sender)
handler.enqueue_xmpp_message(message)
handler.xmpp_identity = session.remote_identity
handler.xmpp_session = session
else:
sip_message_sender = SIPMessageSender(message)
try:
sip_message_sender.send().wait()
except SIPMessageError as e:
# TODO report back an error stanza
log.error('Error sending SIP Message: %s' % e)
@run_in_green_thread
def _NH_XMPPGotNormalMessage(self, notification):
message = notification.data.message
sip_message_sender = SIPMessageSender(message)
try:
sip_message_sender.send().wait()
except SIPMessageError as e:
# TODO report back an error stanza
log.error('Error sending SIP Message: %s' % e)
@run_in_green_thread
def _NH_XMPPGotComposingIndication(self, notification):
composing_indication = notification.data.composing_indication
sender = composing_indication.sender
recipient = composing_indication.recipient
if not XMPPGatewayConfig.use_msrp_for_chat:
state = 'active' if composing_indication.state == 'composing' else 'idle'
body = IsComposingMessage(state=state, refresh=composing_indication.interval or 30).toxml()
message = NormalMessage(sender, recipient, body, IsComposingDocument.content_type)
sip_message_sender = SIPMessageSender(message)
try:
sip_message_sender.send().wait()
except SIPMessageError as e:
# TODO report back an error stanza
log.error('Error sending SIP Message: %s' % e)
def _NH_XMPPGotPresenceSubscriptionRequest(self, notification):
stanza = notification.data.stanza
# Disregard the resource part, the presence request could be a probe instead of a subscribe
sender_uri = stanza.sender.uri
sender_uri_bare = FrozenURI(sender_uri.user, sender_uri.host)
try:
handler = self.x2s_presence_subscriptions[(sender_uri_bare, stanza.recipient.uri)]
except KeyError:
xmpp_identity = stanza.sender
xmpp_identity.uri = sender_uri_bare
sip_identity = stanza.recipient
handler = X2SPresenceHandler(sip_identity, xmpp_identity)
self.x2s_presence_subscriptions[(sender_uri_bare, stanza.recipient.uri)] = handler
notification.center.add_observer(self, sender=handler)
handler.start()
def _NH_XMPPGotMucJoinRequest(self, notification):
stanza = notification.data.stanza
muc_uri = FrozenURI(stanza.recipient.uri.user, stanza.recipient.uri.host)
nickname = stanza.recipient.uri.resource
try:
handler = self.x2s_muc_sessions[(stanza.sender.uri, muc_uri)]
except KeyError:
xmpp_identity = stanza.sender
sip_identity = stanza.recipient
sip_identity.uri = muc_uri
handler = X2SMucHandler(sip_identity, xmpp_identity, nickname)
handler._first_stanza = stanza
notification.center.add_observer(self, sender=handler)
handler.start()
# Check if there was a pending join request on the SIP side
try:
handler = self.s2x_muc_add_participant_handlers[(muc_uri, FrozenURI(stanza.sender.uri.user, stanza.sender.uri.host))]
except KeyError:
pass
else:
handler.stop()
def _NH_XMPPGotMucAddParticipantRequest(self, notification):
sender = notification.data.sender
recipient = notification.data.recipient
participant = notification.data.participant
muc_uri = FrozenURI(recipient.uri.user, recipient.uri.host)
sender_uri = FrozenURI(sender.uri.user, sender.uri.host)
participant_uri = FrozenURI(participant.uri.user, participant.uri.host)
sender = Identity(sender_uri)
recipient = Identity(muc_uri)
participant = Identity(participant_uri)
try:
handler = self.x2s_muc_add_participant_handlers[(muc_uri, participant_uri)]
except KeyError:
handler = X2SMucInvitationHandler(sender, recipient, participant)
self.x2s_muc_add_participant_handlers[(muc_uri, participant_uri)] = handler
notification.center.add_observer(self, sender=handler)
handler.start()
# Chat session handling
def _NH_ChatSessionDidStart(self, notification):
handler = notification.sender
log.msg('Chat session established sip:%s <--> xmpp:%s' % (handler.sip_identity.uri, handler.xmpp_identity.uri))
for k,v in self.pending_sessions.items():
if v is handler:
del self.pending_sessions[k]
break
self.chat_sessions.add(handler)
def _NH_ChatSessionDidEnd(self, notification):
handler = notification.sender
log.msg('Chat session ended sip:%s <--> xmpp:%s' % (handler.sip_identity.uri, handler.xmpp_identity.uri))
self.chat_sessions.remove(handler)
notification.center.remove_observer(self, sender=handler)
def _NH_ChatSessionDidFail(self, notification):
handler = notification.sender
uris = None
for k,v in self.pending_sessions.items():
if v is handler:
uris = k
del self.pending_sessions[k]
break
sip_uri, xmpp_uri = uris
log.msg('Chat session failed sip:%s <--> xmpp:%s (%s)' % (sip_uri, xmpp_uri, notification.data.reason))
notification.center.remove_observer(self, sender=handler)
# Presence handling
def _NH_S2XPresenceHandlerDidStart(self, notification):
handler = notification.sender
if XMPPGatewayConfig.log_presence:
log.msg('Presence flow 0x%x established %s --> %s' % (id(handler), format_uri(handler.sip_identity.uri, 'sip'), format_uri(handler.xmpp_identity.uri, 'xmpp')))
log.msg('%d SIP --> XMPP and %d XMPP --> SIP presence flows are active' % (len(self.s2x_presence_subscriptions.keys()), len(self.x2s_presence_subscriptions.keys())))
def _NH_S2XPresenceHandlerDidEnd(self, notification):
handler = notification.sender
self.s2x_presence_subscriptions.pop((handler.sip_identity.uri, handler.xmpp_identity.uri), None)
notification.center.remove_observer(self, sender=handler)
if XMPPGatewayConfig.log_presence:
log.msg('Presence flow 0x%x ended %s --> %s' % (id(handler), format_uri(handler.sip_identity.uri, 'sip'), format_uri(handler.xmpp_identity.uri, 'xmpp')))
log.msg('%d SIP --> XMPP and %d XMPP --> SIP presence flows are active' % (len(self.s2x_presence_subscriptions.keys()), len(self.x2s_presence_subscriptions.keys())))
def _NH_X2SPresenceHandlerDidStart(self, notification):
handler = notification.sender
if XMPPGatewayConfig.log_presence:
log.msg('Presence flow 0x%x established %s --> %s' % (id(handler), format_uri(handler.xmpp_identity.uri, 'xmpp'), format_uri(handler.sip_identity.uri, 'sip')))
log.msg('%d SIP --> XMPP and %d XMPP --> SIP presence flows are active' % (len(self.s2x_presence_subscriptions.keys()), len(self.x2s_presence_subscriptions.keys())))
def _NH_X2SPresenceHandlerDidEnd(self, notification):
handler = notification.sender
self.x2s_presence_subscriptions.pop((handler.xmpp_identity.uri, handler.sip_identity.uri), None)
notification.center.remove_observer(self, sender=handler)
if XMPPGatewayConfig.log_presence:
log.msg('Presence flow 0x%x ended %s --> %s' % (id(handler), format_uri(handler.xmpp_identity.uri, 'xmpp'), format_uri(handler.sip_identity.uri, 'sip')))
log.msg('%d SIP --> XMPP and %d XMPP --> SIP presence flows are active' % (len(self.s2x_presence_subscriptions.keys()), len(self.x2s_presence_subscriptions.keys())))
# MUC handling
def _NH_X2SMucHandlerDidStart(self, notification):
handler = notification.sender
log.msg('Multiparty session established xmpp:%s --> sip:%s' % (handler.xmpp_identity.uri, handler.sip_identity.uri))
self.x2s_muc_sessions[(handler.xmpp_identity.uri, handler.sip_identity.uri)] = handler
def _NH_X2SMucHandlerDidEnd(self, notification):
handler = notification.sender
log.msg('Multiparty session ended xmpp:%s --> sip:%s' % (handler.xmpp_identity.uri, handler.sip_identity.uri))
self.x2s_muc_sessions.pop((handler.xmpp_identity.uri, handler.sip_identity.uri), None)
notification.center.remove_observer(self, sender=handler)
def _NH_X2SMucInvitationHandlerDidStart(self, notification):
handler = notification.sender
sender_uri = handler.sender.uri
muc_uri = handler.recipient.uri
participant_uri = handler.participant.uri
log.msg('%s invited %s to multiparty chat %s' % (format_uri(sender_uri, 'xmpp'), format_uri(participant_uri), format_uri(muc_uri, 'sip')))
def _NH_X2SMucInvitationHandlerDidEnd(self, notification):
handler = notification.sender
sender_uri = handler.sender.uri
muc_uri = handler.recipient.uri
participant_uri = handler.participant.uri
log.msg('%s added %s to multiparty chat %s' % (format_uri(sender_uri, 'xmpp'), format_uri(participant_uri), format_uri(muc_uri, 'sip')))
del self.x2s_muc_add_participant_handlers[(muc_uri, participant_uri)]
notification.center.remove_observer(self, sender=handler)
def _NH_X2SMucInvitationHandlerDidFail(self, notification):
handler = notification.sender
sender_uri = handler.sender.uri
muc_uri = handler.recipient.uri
participant_uri = handler.participant.uri
log.msg('%s could not add %s to multiparty chat %s: %s' % (format_uri(sender_uri, 'xmpp'), format_uri(participant_uri), format_uri(muc_uri, 'sip'), notification.data.failure))
del self.x2s_muc_add_participant_handlers[(muc_uri, participant_uri)]
notification.center.remove_observer(self, sender=handler)
def _NH_S2XMucInvitationHandlerDidStart(self, notification):
handler = notification.sender
muc_uri = handler.sender.uri
inviter_uri = handler.inviter.uri
recipient_uri = handler.recipient.uri
log.msg("%s invited %s to multiparty chat %s" % (format_uri(inviter_uri, 'sip'), format_uri(recipient_uri, 'xmpp'), format_uri(muc_uri, 'sip')))
def _NH_S2XMucInvitationHandlerDidEnd(self, notification):
handler = notification.sender
muc_uri = handler.sender.uri
inviter_uri = handler.inviter.uri
recipient_uri = handler.recipient.uri
log.msg('%s added %s to multiparty chat %s' % (format_uri(inviter_uri, 'sip'), format_uri(recipient_uri, 'xmpp'), format_uri(muc_uri, 'sip')))
del self.s2x_muc_add_participant_handlers[(muc_uri, recipient_uri)]
notification.center.remove_observer(self, sender=handler)
def _NH_S2XMucInvitationHandlerDidFail(self, notification):
handler = notification.sender
muc_uri = handler.sender.uri
inviter_uri = handler.inviter.uri
recipient_uri = handler.recipient.uri
log.msg('%s could not add %s to multiparty chat %s: %s' % (format_uri(inviter_uri, 'sip'), format_uri(recipient_uri, 'xmpp'), format_uri(muc_uri, 'sip'), str(notification.data.failure)))
del self.s2x_muc_add_participant_handlers[(muc_uri, recipient_uri)]
notification.center.remove_observer(self, sender=handler)
# Media sessions
def _NH_JingleSessionNewIncoming(self, notification):
session = notification.sender
handler = MediaSessionHandler.new_from_jingle_session(session)
if handler is not None:
notification.center.add_observer(self, sender=handler)
def _NH_MediaSessionHandlerDidStart(self, notification):
handler = notification.sender
log.msg('Media session started sip:%s <--> xmpp:%s' % (handler.sip_identity.uri, handler.xmpp_identity.uri))
self.media_sessions.add(handler)
def _NH_MediaSessionHandlerDidEnd(self, notification):
handler = notification.sender
log.msg('Media session ended sip:%s <--> xmpp:%s' % (handler.sip_identity.uri, handler.xmpp_identity.uri))
self.media_sessions.remove(handler)
notification.center.remove_observer(self, sender=handler)
def _NH_MediaSessionHandlerDidFail(self, notification):
handler = notification.sender
log.msg('Media session failed sip:%s <--> xmpp:%s' % (handler.sip_identity.uri, handler.xmpp_identity.uri))
notification.center.remove_observer(self, sender=handler)
diff --git a/sylk/applications/xmppgateway/configuration.py b/sylk/applications/xmppgateway/configuration.py
index 63b851b..8afe6ee 100644
--- a/sylk/applications/xmppgateway/configuration.py
+++ b/sylk/applications/xmppgateway/configuration.py
@@ -1,24 +1,22 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
from application.system import host
from application.configuration import ConfigSection, ConfigSetting
from application.configuration.datatypes import StringList
from sipsimple.configuration.datatypes import NonNegativeInteger
from sylk.configuration.datatypes import IPAddress, Port
class XMPPGatewayConfig(ConfigSection):
__cfgfile__ = 'xmppgateway.ini'
__section__ = 'general'
local_ip = ConfigSetting(type=IPAddress, value=IPAddress(host.default_ip))
local_port = ConfigSetting(type=Port, value=5269)
trace_xmpp = False
log_presence = False
domains = ConfigSetting(type=StringList, value=[])
muc_prefix = 'conference'
sip_session_timeout = ConfigSetting(type=NonNegativeInteger, value=86400)
use_msrp_for_chat = True
diff --git a/sylk/applications/xmppgateway/datatypes.py b/sylk/applications/xmppgateway/datatypes.py
index 7715a1f..90c2759 100644
--- a/sylk/applications/xmppgateway/datatypes.py
+++ b/sylk/applications/xmppgateway/datatypes.py
@@ -1,155 +1,153 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
import hashlib
import random
import string
from application.python.descriptor import WriteOnceAttribute
from sipsimple.core import BaseSIPURI, SIPURI, SIPCoreError
from twisted.words.protocols.jabber.jid import JID
sylkserver_prefix = hashlib.md5('sylkserver').hexdigest()
def generate_sylk_resource():
r = 'sylk-'+''.join(random.choice(string.ascii_letters+string.digits) for x in range(32))
return r.encode('hex')
def is_sylk_resource(r):
if r.startswith('urn:uuid:') or len(r) != 74:
return False
try:
decoded = r.decode('hex')
except TypeError:
return False
else:
return decoded.startswith('sylk-')
def encode_resource(r):
return r.encode('utf-8').encode('hex')
def decode_resource(r):
return r.decode('hex').decode('utf-8')
class BaseURI(object):
def __init__(self, user, host, resource=None):
self.user = user
self.host = host
self.resource = resource
@classmethod
def parse(cls, value):
if isinstance(value, BaseSIPURI):
user = unicode(value.user)
host = unicode(value.host)
resource = unicode(value.parameters.get('gr', '')) or None
return cls(user, host, resource)
elif isinstance(value, JID):
user = value.user
host = value.host
resource = value.resource
return cls(user, host, resource)
elif not isinstance(value, basestring):
raise TypeError('uri needs to be a string')
if not value.startswith(('sip:', 'sips:', 'xmpp:')):
raise ValueError('invalid uri scheme for %s' % value)
if value.startswith(('sip:', 'sips:')):
try:
uri = SIPURI.parse(value)
except SIPCoreError:
raise ValueError('invalid SIP uri: %s' % value)
user = unicode(uri.user)
host = unicode(uri.host)
resource = unicode(uri.parameters.get('gr', '')) or None
else:
try:
jid = JID(value[5:])
except Exception:
raise ValueError('invalid XMPP uri: %s' % value)
user = jid.user
host = jid.host
resource = jid.resource
return cls(user, host, resource)
@classmethod
def new(cls, uri):
if not isinstance(uri, BaseURI):
raise TypeError('%s is not a valid URI type' % type(uri))
return cls(uri.user, uri.host, uri.resource)
def as_sip_uri(self):
uri = SIPURI(user=str(self.user), host=str(self.host))
if self.resource is not None:
uri.parameters['gr'] = self.resource.encode('utf-8')
return uri
def as_xmpp_jid(self):
return JID(tuple=(self.user, self.host, self.resource))
def __eq__(self, other):
if isinstance(other, BaseURI):
return self.user == other.user and self.host == other.host and self.resource == other.resource
elif isinstance(other, basestring):
try:
other = BaseURI.parse(other)
except ValueError:
return False
else:
return self.user == other.user and self.host == other.host and self.resource == other.resource
else:
return NotImplemented
def __ne__(self, other):
equal = self.__eq__(other)
return NotImplemented if equal is NotImplemented else not equal
def __repr__(self):
return '%s(user=%r, host=%r, resource=%r)' % (self.__class__.__name__, self.user, self.host, self.resource)
def __unicode__(self):
return u'%s@%s' % (self.user, self.host)
def __str__(self):
return unicode(self).encode('utf-8')
class URI(BaseURI):
pass
class FrozenURI(BaseURI):
user = WriteOnceAttribute()
host = WriteOnceAttribute()
resource = WriteOnceAttribute()
def __hash__(self):
return hash((self.user, self.host, self.resource))
class Identity(object):
def __init__(self, uri, display_name=None):
self.uri = uri
self.display_name = display_name
def __eq__(self, other):
if isinstance(other, Identity):
return self.uri == other.uri and self.display_name == other.display_name
else:
return NotImplemented
def __ne__(self, other):
equal = self.__eq__(other)
return NotImplemented if equal is NotImplemented else not equal
def __unicode__(self):
if self.display_name is not None:
return u'%s <%s>' % (self.display_name, self.uri)
else:
return u'%s' % self.uri
def __str__(self):
return unicode(self).encode('utf-8')
diff --git a/sylk/applications/xmppgateway/im.py b/sylk/applications/xmppgateway/im.py
index 200e068..083ef69 100644
--- a/sylk/applications/xmppgateway/im.py
+++ b/sylk/applications/xmppgateway/im.py
@@ -1,444 +1,442 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.descriptor import WriteOnceAttribute
from collections import deque
from eventlib import coros
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import SIPURI
from sipsimple.core import ContactHeader, FromHeader, RouteHeader, ToHeader
from sipsimple.core import Message as SIPMessageRequest
from sipsimple.lookup import DNSLookup, DNSLookupError
from sipsimple.streams import MediaStreamRegistry
from sipsimple.streams.msrp.chat import ChatIdentity
from sipsimple.threading import run_in_twisted_thread
from sipsimple.threading.green import run_in_green_thread, run_in_waitable_green_thread
from twisted.internet import reactor
from zope.interface import implements
from sylk.accounts import DefaultAccount
from sylk.applications.xmppgateway.configuration import XMPPGatewayConfig
from sylk.applications.xmppgateway.datatypes import Identity, FrozenURI, generate_sylk_resource, encode_resource
from sylk.applications.xmppgateway.logger import log
from sylk.applications.xmppgateway.xmpp import XMPPManager
from sylk.applications.xmppgateway.xmpp.session import XMPPChatSession
from sylk.applications.xmppgateway.xmpp.stanzas import ChatMessage
from sylk.session import Session
__all__ = ['ChatSessionHandler', 'SIPMessageSender', 'SIPMessageError']
SESSION_TIMEOUT = XMPPGatewayConfig.sip_session_timeout
class ChatSessionHandler(object):
implements(IObserver)
sip_identity = WriteOnceAttribute()
xmpp_identity = WriteOnceAttribute()
def __init__(self):
self.started = False
self.ended = False
self.sip_session = None
self.msrp_stream = None
self._sip_session_timer = None
self.use_receipts = False
self.xmpp_session = None
self._xmpp_message_queue = deque()
self._pending_msrp_chunks = {}
self._pending_xmpp_stanzas = {}
def _set_started(self, value):
old_value = self.__dict__.get('started', False)
self.__dict__['started'] = value
if not old_value and value:
NotificationCenter().post_notification('ChatSessionDidStart', sender=self)
self._send_queued_messages()
def _get_started(self):
return self.__dict__['started']
started = property(_get_started, _set_started)
del _get_started, _set_started
def _set_xmpp_session(self, session):
self.__dict__['xmpp_session'] = session
if session is not None:
# Reet SIP session timer in case it's active
if self._sip_session_timer is not None and self._sip_session_timer.active():
self._sip_session_timer.reset(SESSION_TIMEOUT)
NotificationCenter().add_observer(self, sender=session)
session.start()
# Reet SIP session timer in case it's active
if self._sip_session_timer is not None and self._sip_session_timer.active():
self._sip_session_timer.reset(SESSION_TIMEOUT)
def _get_xmpp_session(self):
return self.__dict__['xmpp_session']
xmpp_session = property(_get_xmpp_session, _set_xmpp_session)
del _get_xmpp_session, _set_xmpp_session
@classmethod
def new_from_sip_session(cls, sip_identity, session):
instance = cls()
instance.sip_identity = sip_identity
instance._start_incoming_sip_session(session)
return instance
@classmethod
def new_from_xmpp_stanza(cls, xmpp_identity, recipient):
instance = cls()
instance.xmpp_identity = xmpp_identity
instance._start_outgoing_sip_session(recipient)
return instance
@run_in_green_thread
def _start_incoming_sip_session(self, session):
self.sip_session = session
self.msrp_stream = next(stream for stream in session.proposed_streams if stream.type=='chat')
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.sip_session)
notification_center.add_observer(self, sender=self.msrp_stream)
self.sip_session.accept([self.msrp_stream])
@run_in_green_thread
def _start_outgoing_sip_session(self, target_uri):
notification_center = NotificationCenter()
# self.xmpp_identity is our local identity
from_uri = self.xmpp_identity.uri.as_sip_uri()
del from_uri.parameters['gr'] # no GRUU in From header
contact_uri = self.xmpp_identity.uri.as_sip_uri()
contact_uri.parameters['gr'] = encode_resource(contact_uri.parameters['gr'].decode('utf-8'))
to_uri = target_uri.as_sip_uri()
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
log.warning('DNS lookup error while looking for %s proxy' % uri)
notification_center.post_notification('ChatSessionDidFail', sender=self, data=NotificationData(reason='DNS lookup error'))
return
self.msrp_stream = MediaStreamRegistry.get('chat')()
route = routes.pop(0)
from_header = FromHeader(from_uri)
to_header = ToHeader(to_uri)
contact_header = ContactHeader(contact_uri)
self.sip_session = Session(account)
notification_center.add_observer(self, sender=self.sip_session)
notification_center.add_observer(self, sender=self.msrp_stream)
self.sip_session.connect(from_header, to_header, contact_header=contact_header, route=route, streams=[self.msrp_stream])
def end(self):
if self.ended:
return
if self._sip_session_timer is not None and self._sip_session_timer.active():
self._sip_session_timer.cancel()
self._sip_session_timer = None
notification_center = NotificationCenter()
if self.sip_session is not None:
notification_center.remove_observer(self, sender=self.sip_session)
notification_center.remove_observer(self, sender=self.msrp_stream)
self.sip_session.end()
self.sip_session = None
self.msrp_stream = None
if self.xmpp_session is not None:
notification_center.remove_observer(self, sender=self.xmpp_session)
self.xmpp_session.end()
self.xmpp_session = None
self.ended = True
if self.started:
notification_center.post_notification('ChatSessionDidEnd', sender=self)
else:
notification_center.post_notification('ChatSessionDidFail', sender=self, data=NotificationData(reason='Ended before actually started'))
def enqueue_xmpp_message(self, message):
self._xmpp_message_queue.append(message)
if self.started:
self._send_queued_messages()
def _send_queued_messages(self):
if self._xmpp_message_queue:
while self._xmpp_message_queue:
message = self._xmpp_message_queue.popleft()
if message.body is None:
continue
notify_progress = message.use_receipt
sender_uri = message.sender.uri.as_sip_uri()
sender_uri.parameters['gr'] = encode_resource(sender_uri.parameters['gr'].decode('utf-8'))
sender = ChatIdentity(sender_uri)
self.msrp_stream.send_message(message.body, 'text/plain', sender=sender, message_id=message.id, notify_progress=message.use_receipt)
self.msrp_stream.send_composing_indication('idle', 30, sender=sender)
def _inactivity_timeout(self):
log.msg("Ending SIP session %s due to inactivity" % self.sip_session.call_id)
self.sip_session.end()
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionDidStart(self, notification):
log.msg("SIP session %s started" % self.sip_session.call_id)
self._sip_session_timer = reactor.callLater(SESSION_TIMEOUT, self._inactivity_timeout)
if self.sip_session.direction == 'outgoing':
# Time to set sip_identity and create the XMPPChatSession
contact_uri = self.sip_session._invitation.remote_contact_header.uri
if contact_uri.parameters.get('gr') is not None:
sip_leg_uri = FrozenURI(contact_uri.user, contact_uri.host, contact_uri.parameters.get('gr'))
else:
tmp = self.sip_session.remote_identity.uri
sip_leg_uri = FrozenURI(tmp.user, tmp.host, generate_sylk_resource())
self.sip_identity = Identity(sip_leg_uri, self.sip_session.remote_identity.display_name)
session = XMPPChatSession(local_identity=self.sip_identity, remote_identity=self.xmpp_identity)
self.xmpp_session = session
# Session is now established on both ends
self.started = True
# Try to wakeup XMPP clients
self.xmpp_session.send_composing_indication('active')
self.xmpp_session.send_message(' ', 'text/plain')
else:
if self.xmpp_session is not None:
# Session is now established on both ends
self.started = True
# Try to wakeup XMPP clients
self.xmpp_session.send_composing_indication('active')
self.xmpp_session.send_message(' ', 'text/plain')
else:
# Try to wakeup XMPP clients
sender = self.sip_identity
tmp = self.sip_session.local_identity.uri
recipient_uri = FrozenURI(tmp.user, tmp.host)
recipient = Identity(recipient_uri)
xmpp_manager = XMPPManager()
xmpp_manager.send_stanza(ChatMessage(sender, recipient, ' ', 'text/plain'))
# Send queued messages
self._send_queued_messages()
def _NH_SIPSessionDidEnd(self, notification):
log.msg("SIP session %s ended" % self.sip_session.call_id)
notification.center.remove_observer(self, sender=self.sip_session)
notification.center.remove_observer(self, sender=self.msrp_stream)
self.sip_session = None
self.msrp_stream = None
self.end()
def _NH_SIPSessionDidFail(self, notification):
log.msg("SIP session %s failed" % self.sip_session.call_id)
notification.center.remove_observer(self, sender=self.sip_session)
notification.center.remove_observer(self, sender=self.msrp_stream)
self.sip_session = None
self.msrp_stream = None
self.end()
def _NH_SIPSessionNewProposal(self, notification):
if notification.data.originator == 'remote':
self.sip_session.reject_proposal()
def _NH_SIPSessionTransferNewIncoming(self, notification):
self.sip_session.reject_transfer(403)
def _NH_ChatStreamGotMessage(self, notification):
# Notification is sent by the MSRP stream
message = notification.data.message
content_type = message.content_type.lower()
if content_type not in ('text/plain', 'text/html'):
return
if content_type == 'text/plain':
html_body = None
body = message.content
else:
html_body = message.content
body = None
if self._sip_session_timer is not None and self._sip_session_timer.active():
self._sip_session_timer.reset(SESSION_TIMEOUT)
chunk = notification.data.chunk
if self.started:
self.xmpp_session.send_message(body, html_body, message_id=chunk.message_id)
if self.use_receipts:
self._pending_msrp_chunks[chunk.message_id] = chunk
else:
self.msrp_stream.msrp_session.send_report(chunk, 200, 'OK')
else:
sender = self.sip_identity
recipient_uri = FrozenURI.parse(message.recipients[0].uri)
recipient = Identity(recipient_uri, message.recipients[0].display_name)
xmpp_manager = XMPPManager()
xmpp_manager.send_stanza(ChatMessage(sender, recipient, body, html_body))
self.msrp_stream.msrp_session.send_report(chunk, 200, 'OK')
def _NH_ChatStreamGotComposingIndication(self, notification):
# Notification is sent by the MSRP stream
if self._sip_session_timer is not None and self._sip_session_timer.active():
self._sip_session_timer.reset(SESSION_TIMEOUT)
if not self.started:
return
state = None
if notification.data.state == 'active':
state = 'composing'
elif notification.data.state == 'idle':
state = 'paused'
if state is not None:
self.xmpp_session.send_composing_indication(state)
def _NH_ChatStreamDidDeliverMessage(self, notification):
if self.started:
message = self._pending_xmpp_stanzas.pop(notification.data.message_id, None)
if message is not None:
self.xmpp_session.send_receipt_acknowledgement(message.id)
def _NH_ChatStreamDidNotDeliverMessage(self, notification):
if self.started:
message = self._pending_xmpp_stanzas.pop(notification.data.message_id, None)
if message is not None:
self.xmpp_session.send_error(message, 'TODO', []) # TODO
def _NH_XMPPChatSessionDidStart(self, notification):
if self.sip_session is not None:
# Session is now established on both ends
self.started = True
def _NH_XMPPChatSessionDidEnd(self, notification):
notification.center.remove_observer(self, sender=self.xmpp_session)
self.xmpp_session = None
self.end()
def _NH_XMPPChatSessionGotMessage(self, notification):
if self.sip_session is None or self.sip_session.state != 'connected':
self._xmpp_message_queue.append(notification.data.message)
return
if self._sip_session_timer is not None and self._sip_session_timer.active():
self._sip_session_timer.reset(SESSION_TIMEOUT)
message = notification.data.message
sender_uri = message.sender.uri.as_sip_uri()
del sender_uri.parameters['gr'] # no GRUU in CPIM From header
sender = ChatIdentity(sender_uri)
self.use_receipts = message.use_receipt
if not message.use_receipt:
notify_progress = False
else:
notify_progress = True
self._pending_xmpp_stanzas[message.id] = message
# Prefer plaintext
self.msrp_stream.send_message(message.body, 'text/plain', sender=sender, message_id=message.id, notify_progress=notify_progress)
self.msrp_stream.send_composing_indication('idle', 30, sender=sender)
def _NH_XMPPChatSessionGotComposingIndication(self, notification):
if self.sip_session is None or self.sip_session.state != 'connected':
return
if self._sip_session_timer is not None and self._sip_session_timer.active():
self._sip_session_timer.reset(SESSION_TIMEOUT)
message = notification.data.message
state = None
if message.state == 'composing':
state = 'active'
elif message.state == 'paused':
state = 'idle'
if state is not None:
sender_uri = message.sender.uri.as_sip_uri()
del sender_uri.parameters['gr'] # no GRUU in CPIM From header
sender = ChatIdentity(sender_uri)
self.msrp_stream.send_composing_indication(state, 30, sender=sender)
if message.use_receipt:
self.xmpp_session.send_receipt_acknowledgement(message.id)
def _NH_XMPPChatSessionDidDeliverMessage(self, notification):
chunk = self._pending_msrp_chunks.pop(notification.data.message_id, None)
if chunk is not None:
self.msrp_stream.msrp_session.send_report(chunk, 200, 'OK')
def _NH_XMPPChatSessionDidNotDeliverMessage(self, notification):
chunk = self._pending_msrp_chunks.pop(notification.data.message_id, None)
if chunk is not None:
self.msrp_stream.msrp_session.send_report(chunk, notification.data.code, notification.data.reason)
def chunks(text, size):
for i in xrange(0, len(text), size):
yield text[i:i+size]
class SIPMessageError(Exception):
def __init__(self, code, reason):
Exception.__init__(self, reason)
self.code = code
self.reason = reason
class SIPMessageSender(object):
implements(IObserver)
def __init__(self, message):
# TODO: sometimes we may want to send it to the GRUU, for example when a XMPP client
# replies to one of our messages. MESSAGE requests don't need a Contact header, though
# so how should we communicate our GRUU to the recipient?
self.from_uri = message.sender.uri.as_sip_uri()
self.from_uri.parameters.pop('gr', None) # No GRUU in From header
self.to_uri = message.recipient.uri.as_sip_uri()
self.to_uri.parameters.pop('gr', None) # Don't send it to the GRUU
self.body = message.body
self.content_type = 'text/plain'
self._requests = set()
self._channel = coros.queue()
@run_in_waitable_green_thread
def send(self):
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = self.to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
msg = 'DNS lookup error while looking for %s proxy' % uri
log.warning(msg)
raise SIPMessageError(0, msg)
else:
route = routes.pop(0)
from_header = FromHeader(self.from_uri)
to_header = ToHeader(self.to_uri)
route_header = RouteHeader(route.uri)
notification_center = NotificationCenter()
for chunk in chunks(self.body, 1000):
request = SIPMessageRequest(from_header, to_header, route_header, self.content_type, self.body)
notification_center.add_observer(self, sender=request)
self._requests.add(request)
request.send()
error = None
count = len(self._requests)
while count > 0:
notification = self._channel.wait()
if notification.name == 'SIPMessageDidFail':
error = (notification.data.code, notification.data.reason)
count -= 1
self._requests.clear()
if error is not None:
raise SIPMessageError(*error)
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPMessageDidSucceed(self, notification):
notification.center.remove_observer(self, sender=notification.sender)
self._channel.send(notification)
def _NH_SIPMessageDidFail(self, notification):
notification.center.remove_observer(self, sender=notification.sender)
self._channel.send(notification)
diff --git a/sylk/applications/xmppgateway/logger.py b/sylk/applications/xmppgateway/logger.py
index 1fc09c6..e2405c7 100644
--- a/sylk/applications/xmppgateway/logger.py
+++ b/sylk/applications/xmppgateway/logger.py
@@ -1,9 +1,7 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
__all__ = ['log']
from sylk.applications import ApplicationLogger
log = ApplicationLogger.for_package(__package__)
diff --git a/sylk/applications/xmppgateway/media.py b/sylk/applications/xmppgateway/media.py
index da58b17..d279b87 100644
--- a/sylk/applications/xmppgateway/media.py
+++ b/sylk/applications/xmppgateway/media.py
@@ -1,328 +1,326 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from eventlib.twistedutil import block_on
from sipsimple.audio import AudioConference
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import FromHeader, ToHeader
from sipsimple.core import SIPURI, SIPCoreError
from sipsimple.lookup import DNSLookup, DNSLookupError
from sipsimple.streams import MediaStreamRegistry as SIPMediaStreamRegistry
from sipsimple.threading import run_in_twisted_thread
from sipsimple.threading.green import run_in_green_thread
from zope.interface import implements
from sylk.accounts import DefaultAccount
from sylk.applications.xmppgateway.datatypes import Identity, FrozenURI, generate_sylk_resource, decode_resource
from sylk.applications.xmppgateway.logger import log
from sylk.applications.xmppgateway.xmpp import XMPPManager
from sylk.applications.xmppgateway.xmpp.jingle.session import JingleSession
from sylk.applications.xmppgateway.xmpp.jingle.streams import MediaStreamRegistry as JingleMediaStreamRegistry
from sylk.applications.xmppgateway.xmpp.stanzas import jingle
from sylk.session import Session
__all__ = ['MediaSessionHandler']
class MediaSessionHandler(object):
implements(IObserver)
def __init__(self):
self.started = False
self.ended = False
self._sip_identity = None
self._xmpp_identity = None
self._audio_bidge = AudioConference()
self.sip_session = None
self.jingle_session = None
@classmethod
def new_from_sip_session(cls, session):
proposed_stream_types = set([stream.type for stream in session.proposed_streams])
streams = []
for stream_type in proposed_stream_types:
try:
klass = JingleMediaStreamRegistry().get(stream_type)
except Exception:
continue
streams.append(klass())
if not streams:
session.reject(488)
return None
session.send_ring_indication()
instance = cls()
NotificationCenter().add_observer(instance, sender=session)
# Get URI representing the SIP side
contact_uri = session._invitation.remote_contact_header.uri
if contact_uri.parameters.get('gr') is not None:
sip_leg_uri = FrozenURI(contact_uri.user, contact_uri.host, contact_uri.parameters.get('gr'))
else:
tmp = session.remote_identity.uri
sip_leg_uri = FrozenURI(tmp.user, tmp.host, generate_sylk_resource())
instance._sip_identity = Identity(sip_leg_uri)
# Get URI representing the XMPP side
request_uri = session.request_uri
remote_resource = request_uri.parameters.get('gr', None)
if remote_resource is not None:
try:
remote_resource = decode_resource(remote_resource)
except (TypeError, UnicodeError):
remote_resource = None
xmpp_leg_uri = FrozenURI(request_uri.user, request_uri.host, remote_resource)
instance._xmpp_identity = Identity(xmpp_leg_uri)
instance.sip_session = session
instance._start_outgoing_jingle_session(streams)
return instance
@classmethod
def new_from_jingle_session(cls, session):
proposed_stream_types = set([stream.type for stream in session.proposed_streams])
streams = []
for stream_type in proposed_stream_types:
try:
klass = SIPMediaStreamRegistry.get(stream_type)
except Exception:
continue
streams.append(klass())
if not streams:
session.reject('unsupported-applications')
return None
session.send_ring_indication()
instance = cls()
NotificationCenter().add_observer(instance, sender=session)
instance._xmpp_identity = session.remote_identity
instance._sip_identity = session.local_identity
instance.jingle_session = session
instance._start_outgoing_sip_session(streams)
return instance
@property
def sip_identity(self):
return self._sip_identity
@property
def xmpp_identity(self):
return self._xmpp_identity
def _set_started(self, value):
old_value = self.__dict__.get('started', False)
self.__dict__['started'] = value
if not old_value and value:
NotificationCenter().post_notification('MediaSessionHandlerDidStart', sender=self)
def _get_started(self):
return self.__dict__['started']
started = property(_get_started, _set_started)
del _get_started, _set_started
@run_in_green_thread
def _start_outgoing_sip_session(self, streams):
notification_center = NotificationCenter()
# self.xmpp_identity is our local identity on the SIP side
from_uri = self.xmpp_identity.uri.as_sip_uri()
from_uri.parameters.pop('gr', None) # no GRUU in From header
to_uri = self.sip_identity.uri.as_sip_uri()
to_uri.parameters.pop('gr', None) # no GRUU in To header
# TODO: need to fix GRUU in the proxy
#contact_uri = self.xmpp_identity.uri.as_sip_uri()
#contact_uri.parameters['gr'] = encode_resource(contact_uri.parameters['gr'].decode('utf-8'))
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
log.warning('DNS lookup error while looking for %s proxy' % uri)
notification_center.post_notification('MedialSessionHandlerDidFail', sender=self, data=NotificationData(reason='DNS lookup error'))
return
route = routes.pop(0)
from_header = FromHeader(from_uri)
to_header = ToHeader(to_uri)
self.sip_session = Session(account)
notification_center.add_observer(self, sender=self.sip_session)
self.sip_session.connect(from_header, to_header, route=route, streams=streams)
@run_in_green_thread
def _start_outgoing_jingle_session(self, streams):
if self.xmpp_identity.uri.resource is not None:
self.sip_session.reject()
return
xmpp_manager = XMPPManager()
local_jid = self.sip_identity.uri.as_xmpp_jid()
remote_jid = self.xmpp_identity.uri.as_xmpp_jid()
# If this was an invitation to a conference, use the information in the Referred-By header
if self.sip_identity.uri.host in xmpp_manager.muc_domains and self.sip_session.transfer_info and self.sip_session.transfer_info.referred_by:
try:
referred_by_uri = SIPURI.parse(self.sip_session.transfer_info.referred_by)
except SIPCoreError:
self.sip_session.reject(488)
return
else:
inviter_uri = FrozenURI(referred_by_uri.user, referred_by_uri.host)
local_jid = inviter_uri.as_xmpp_jid()
# Use disco to gather potential JIDs to call
d = xmpp_manager.disco_client_protocol.requestItems(remote_jid, sender=local_jid)
try:
items = block_on(d)
except Exception:
items = []
if not items:
self.sip_session.reject(480)
return
# Check which items support Jingle
valid = []
for item in items:
d = xmpp_manager.disco_client_protocol.requestInfo(item.entity, nodeIdentifier=item.nodeIdentifier, sender=local_jid)
try:
info = block_on(d)
except Exception:
continue
if jingle.NS_JINGLE in info.features and jingle.NS_JINGLE_APPS_RTP in info.features:
valid.append(item.entity)
if not valid:
self.sip_session.reject(480)
return
# TODO: start multiple sessions?
self._xmpp_identity = Identity(FrozenURI.parse(valid[0]))
notification_center = NotificationCenter()
if self.sip_identity.uri.host in xmpp_manager.muc_domains:
self.jingle_session = JingleSession(xmpp_manager.jingle_coin_protocol)
else:
self.jingle_session = JingleSession(xmpp_manager.jingle_protocol)
notification_center.add_observer(self, sender=self.jingle_session)
self.jingle_session.connect(self.sip_identity, self.xmpp_identity, streams, is_focus=self.sip_session.remote_focus)
def end(self):
if self.ended:
return
notification_center = NotificationCenter()
if self.sip_session is not None:
notification_center.remove_observer(self, sender=self.sip_session)
if self.sip_session.direction == 'incoming' and not self.started:
self.sip_session.reject()
else:
self.sip_session.end()
self.sip_session = None
if self.jingle_session is not None:
notification_center.remove_observer(self, sender=self.jingle_session)
if self.jingle_session.direction == 'incoming' and not self.started:
self.jingle_session.reject()
else:
self.jingle_session.end()
self.jingle_session = None
self.ended = True
if self.started:
notification_center.post_notification('MediaSessionHandlerDidEnd', sender=self)
else:
notification_center.post_notification('MediaSessionHandlerDidFail', sender=self)
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionDidStart(self, notification):
log.msg("SIP session %s started" % self.sip_session.call_id)
if self.sip_session.direction == 'outgoing':
# Time to accept the Jingle session and bridge them together
try:
audio_stream = next(stream for stream in self.sip_session.streams if stream.type=='audio')
except StopIteration:
pass
else:
self._audio_bidge.add(audio_stream)
self.jingle_session.accept(self.jingle_session.proposed_streams, is_focus=self.sip_session.remote_focus)
else:
# Both sessions have been accepted now
self.started = True
try:
audio_stream = next(stream for stream in self.sip_session.streams if stream.type=='audio')
except StopIteration:
pass
else:
self._audio_bidge.add(audio_stream)
def _NH_SIPSessionDidEnd(self, notification):
log.msg("SIP session %s ended" % self.sip_session.call_id)
notification.center.remove_observer(self, sender=self.sip_session)
self.sip_session = None
self.end()
def _NH_SIPSessionDidFail(self, notification):
log.msg("SIP session %s failed (%s)" % (self.sip_session.call_id, notification.data.reason))
notification.center.remove_observer(self, sender=self.sip_session)
self.sip_session = None
self.end()
def _NH_SIPSessionNewProposal(self, notification):
if notification.data.originator == 'remote':
self.sip_session.reject_proposal()
def _NH_SIPSessionTransferNewIncoming(self, notification):
self.sip_session.reject_transfer(403)
def _NH_SIPSessionDidChangeHoldState(self, notification):
if notification.data.originator == 'remote':
if notification.data.on_hold:
self.jingle_session.hold()
else:
self.jingle_session.unhold()
def _NH_SIPSessionGotConferenceInfo(self, notification):
self.jingle_session._send_conference_info(notification.data.conference_info.toxml())
def _NH_JingleSessionDidStart(self, notification):
log.msg("Jingle session %s started" % notification.sender.id)
if self.jingle_session.direction == 'incoming':
# Both sessions have been accepted now
self.started = True
try:
audio_stream = next(stream for stream in self.jingle_session.streams if stream.type=='audio')
except StopIteration:
pass
else:
self._audio_bidge.add(audio_stream)
else:
# Time to accept the Jingle session and bridge them together
try:
audio_stream = next(stream for stream in self.jingle_session.streams if stream.type=='audio')
except StopIteration:
pass
else:
self._audio_bidge.add(audio_stream)
self.sip_session.accept(self.sip_session.proposed_streams)
def _NH_JingleSessionDidEnd(self, notification):
log.msg("Jingle session %s ended" % notification.sender.id)
notification.center.remove_observer(self, sender=self.jingle_session)
self.jingle_session = None
self.end()
def _NH_JingleSessionDidFail(self, notification):
log.msg("Jingle session %s failed (%s)" % (notification.sender.id, notification.data.reason))
notification.center.remove_observer(self, sender=self.jingle_session)
self.jingle_session = None
self.end()
def _NH_JingleSessionDidChangeHoldState(self, notification):
if notification.data.originator == 'remote':
if notification.data.on_hold:
self.sip_session.hold()
else:
self.sip_session.unhold()
diff --git a/sylk/applications/xmppgateway/muc.py b/sylk/applications/xmppgateway/muc.py
index d0249b5..c4fe7fe 100644
--- a/sylk/applications/xmppgateway/muc.py
+++ b/sylk/applications/xmppgateway/muc.py
@@ -1,469 +1,467 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
import random
import uuid
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null, limit
from application.python.descriptor import WriteOnceAttribute
from eventlib import coros, proc
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import Engine, SIPURI, SIPCoreError, Referral, sip_status_messages
from sipsimple.core import ContactHeader, FromHeader, ToHeader, ReferToHeader, RouteHeader
from sipsimple.lookup import DNSLookup, DNSLookupError
from sipsimple.streams import MediaStreamRegistry
from sipsimple.streams.msrp.chat import ChatStreamError, ChatIdentity
from sipsimple.threading import run_in_twisted_thread
from sipsimple.threading.green import run_in_green_thread
from time import time
from twisted.internet import reactor
from zope.interface import implements
from sylk.accounts import DefaultAccount
from sylk.applications.xmppgateway.datatypes import Identity, FrozenURI, encode_resource
from sylk.applications.xmppgateway.logger import log
from sylk.applications.xmppgateway.xmpp import XMPPManager
from sylk.applications.xmppgateway.xmpp.session import XMPPIncomingMucSession
from sylk.applications.xmppgateway.xmpp.stanzas import MUCAvailabilityPresence, MUCErrorPresence, OutgoingInvitationMessage, STANZAS_NS
from sylk.configuration import SIPConfig
from sylk.session import Session
class ReferralError(Exception):
def __init__(self, error, code=0):
self.error = error
self.code = code
class SIPReferralDidFail(Exception):
def __init__(self, data):
self.data = data
class MucInvitationFailure(object):
def __init__(self, code, reason):
self.code = code
self.reason = reason
def __str__(self):
return '%s (%s)' % (self.code, self.reason)
class X2SMucInvitationHandler(object):
implements(IObserver)
def __init__(self, sender, recipient, participant):
self.sender = sender
self.recipient = recipient
self.participant = participant
self.active = False
self.route = None
self._channel = coros.queue()
self._referral = None
self._failure = None
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='NetworkConditionsDidChange')
proc.spawn(self._run)
notification_center.post_notification('X2SMucInvitationHandlerDidStart', sender=self)
def _run(self):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
sender_uri = self.sender.uri.as_sip_uri()
recipient_uri = self.recipient.uri.as_sip_uri()
participant_uri = self.participant.uri.as_sip_uri()
try:
# Lookup routes
account = DefaultAccount()
if account.sip.outbound_proxy is not None and account.sip.outbound_proxy.transport in settings.sip.transport_list:
uri = SIPURI(host=account.sip.outbound_proxy.host, port=account.sip.outbound_proxy.port, parameters={'transport': account.sip.outbound_proxy.transport})
elif account.sip.always_use_my_proxy:
uri = SIPURI(host=account.id.domain)
else:
uri = SIPURI.new(recipient_uri)
lookup = DNSLookup()
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError, e:
timeout = random.uniform(15, 30)
raise ReferralError(error='DNS lookup failed: %s' % e)
timeout = time() + 30
for route in routes:
self.route = route
remaining_time = timeout - time()
if remaining_time > 0:
transport = route.transport
parameters = {} if transport=='udp' else {'transport': transport}
contact_uri = SIPURI(user=account.contact.username, host=SIPConfig.local_ip.normalized, port=getattr(Engine(), '%s_port' % transport), parameters=parameters)
refer_to_header = ReferToHeader(str(participant_uri))
refer_to_header.parameters['method'] = 'INVITE'
referral = Referral(recipient_uri, FromHeader(sender_uri),
ToHeader(recipient_uri),
refer_to_header,
ContactHeader(contact_uri),
RouteHeader(route.uri),
account.credentials)
notification_center.add_observer(self, sender=referral)
try:
referral.send_refer(timeout=limit(remaining_time, min=1, max=5))
except SIPCoreError:
notification_center.remove_observer(self, sender=referral)
timeout = 5
raise ReferralError(error='Internal error')
self._referral = referral
try:
while True:
notification = self._channel.wait()
if notification.name == 'SIPReferralDidStart':
break
except SIPReferralDidFail, e:
notification_center.remove_observer(self, sender=referral)
self._referral = None
if e.data.code in (403, 405):
raise ReferralError(error=sip_status_messages[e.data.code], code=e.data.code)
else:
# Otherwise just try the next route
continue
else:
break
else:
self.route = None
raise ReferralError(error='No more routes to try')
# At this point it is subscribed. Handle notifications and ending/failures.
try:
self.active = True
while True:
notification = self._channel.wait()
if notification.name == 'SIPReferralDidEnd':
break
except SIPReferralDidFail, e:
notification_center.remove_observer(self, sender=self._referral)
raise ReferralError(error=e.data.reason, code=e.data.code)
else:
notification_center.remove_observer(self, sender=self._referral)
finally:
self.active = False
except ReferralError, e:
self._failure = MucInvitationFailure(e.code, e.error)
finally:
notification_center.remove_observer(self, name='NetworkConditionsDidChange')
self._referral = None
if self._failure is not None:
notification_center.post_notification('X2SMucInvitationHandlerDidFail', sender=self, data=NotificationData(failure=self._failure))
else:
notification_center.post_notification('X2SMucInvitationHandlerDidEnd', sender=self)
def _refresh(self):
account = DefaultAccount()
transport = self.route.transport
parameters = {} if transport=='udp' else {'transport': transport}
contact_uri = SIPURI(user=account.contact.username, host=SIPConfig.local_ip.normalized, port=getattr(Engine(), '%s_port' % transport), parameters=parameters)
contact_header = ContactHeader(contact_uri)
self._referral.refresh(contact_header=contact_header, timeout=2)
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPReferralDidStart(self, notification):
self._channel.send(notification)
def _NH_SIPReferralDidEnd(self, notification):
self._channel.send(notification)
def _NH_SIPReferralDidFail(self, notification):
self._channel.send_exception(SIPReferralDidFail(notification.data))
def _NH_SIPReferralGotNotify(self, notification):
self._channel.send(notification)
def _NH_NetworkConditionsDidChange(self, notification):
if self.active:
self._refresh()
class S2XMucInvitationHandler(object):
implements(IObserver)
def __init__(self, session, sender, recipient, inviter):
self.session = session
self.sender = sender
self.recipient = recipient
self.inviter = inviter
self._timer = None
self._failure = None
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.session)
stanza = OutgoingInvitationMessage(self.sender, self.recipient, self.inviter, id='MUC.'+uuid.uuid4().hex)
xmpp_manager = XMPPManager()
xmpp_manager.send_muc_stanza(stanza)
self._timer = reactor.callLater(90, self._timeout)
notification_center.post_notification('S2XMucInvitationHandlerDidStart', sender=self)
def stop(self):
if self._timer is not None and self._timer.active():
self._timer.cancel()
self._timer = None
notification_center = NotificationCenter()
if self.session is not None:
notification_center.remove_observer(self, sender=self.session)
reactor.callLater(5, self._end_session, self.session)
self.session = None
if self._failure is not None:
notification_center.post_notification('S2XMucInvitationHandlerDidFail', sender=self, data=NotificationData(failure=self._failure))
else:
notification_center.post_notification('S2XMucInvitationHandlerDidEnd', sender=self)
def _end_session(self, session):
try:
session.end(480)
except Exception:
pass
def _timeout(self):
NotificationCenter().remove_observer(self, sender=self.session)
try:
self.session.end(408)
except Exception:
pass
self.session = None
self._failure = MucInvitationFailure('Timeout', 408)
self.stop()
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionDidFail(self, notification):
notification.center.remove_observer(self, sender=self.session)
self.session = None
self._failure = MucInvitationFailure(notification.data.reason or notification.data.failure_reason, notification.data.code)
self.stop()
class X2SMucHandler(object):
implements(IObserver)
sip_identity = WriteOnceAttribute()
xmpp_identity = WriteOnceAttribute()
def __init__(self, sip_identity, xmpp_identity, nickname):
self.sip_identity = sip_identity
self.xmpp_identity = xmpp_identity
self.nickname = nickname
self._xmpp_muc_session = None
self._sip_session = None
self._msrp_stream = None
self._first_stanza = None
self._pending_nicknames_map = {} # map message ID of MSRP NICKNAME chunk to corresponding stanza
self._pending_messages_map = {} # map message ID of MSRP SEND chunk to corresponding stanza
self._participants = set() # set of (URI, nickname) tuples
self.ended = False
def start(self):
notification_center = NotificationCenter()
self._xmpp_muc_session = XMPPIncomingMucSession(local_identity=self.sip_identity, remote_identity=self.xmpp_identity)
notification_center.add_observer(self, sender=self._xmpp_muc_session)
self._xmpp_muc_session.start()
notification_center.post_notification('X2SMucHandlerDidStart', sender=self)
self._start_sip_session()
def end(self):
if self.ended:
return
notification_center = NotificationCenter()
if self._xmpp_muc_session is not None:
notification_center.remove_observer(self, sender=self._xmpp_muc_session)
# Send indication that the user has been kicked from the room
sender = Identity(FrozenURI(self.sip_identity.uri.user, self.sip_identity.uri.host, self.nickname))
stanza = MUCAvailabilityPresence(sender, self.xmpp_identity, available=False)
stanza.jid = self.xmpp_identity
stanza.muc_statuses.append('307')
xmpp_manager = XMPPManager()
xmpp_manager.send_muc_stanza(stanza)
self._xmpp_muc_session.end()
self._xmpp_muc_session = None
if self._sip_session is not None:
notification_center.remove_observer(self, sender=self._sip_session)
self._sip_session.end()
self._sip_session = None
self.ended = True
notification_center.post_notification('X2SMucHandlerDidEnd', sender=self)
@run_in_green_thread
def _start_sip_session(self):
# self.xmpp_identity is our local identity
from_uri = self.xmpp_identity.uri.as_sip_uri()
del from_uri.parameters['gr'] # no GRUU in From header
contact_uri = self.xmpp_identity.uri.as_sip_uri()
contact_uri.parameters['gr'] = encode_resource(contact_uri.parameters['gr'].decode('utf-8'))
to_uri = self.sip_identity.uri.as_sip_uri()
lookup = DNSLookup()
settings = SIPSimpleSettings()
account = DefaultAccount()
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = to_uri
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError:
log.warning('DNS lookup error while looking for %s proxy' % uri)
self.end()
return
self._msrp_stream = MediaStreamRegistry().get('chat')()
route = routes.pop(0)
from_header = FromHeader(from_uri)
to_header = ToHeader(to_uri)
contact_header = ContactHeader(contact_uri)
self._sip_session = Session(account)
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self._sip_session)
notification_center.add_observer(self, sender=self._msrp_stream)
self._sip_session.connect(from_header, to_header, contact_header=contact_header, route=route, streams=[self._msrp_stream])
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSessionDidStart(self, notification):
log.msg("SIP multiparty session %s started" % self._sip_session.call_id)
if not self._sip_session.remote_focus or not self._msrp_stream.nickname_allowed:
self.end()
return
message_id = self._msrp_stream.set_local_nickname(self.nickname)
self._pending_nicknames_map[message_id] = (self.nickname, self._first_stanza)
self._first_stanza = None
def _NH_SIPSessionDidEnd(self, notification):
log.msg("SIP multiparty session %s ended" % self._sip_session.call_id)
notification.center.remove_observer(self, sender=self._sip_session)
notification.center.remove_observer(self, sender=self._msrp_stream)
self._sip_session = None
self._msrp_stream = None
self.end()
def _NH_SIPSessionDidFail(self, notification):
log.msg("SIP multiparty session %s failed" % self._sip_session.call_id)
notification.center.remove_observer(self, sender=self._sip_session)
notification.center.remove_observer(self, sender=self._msrp_stream)
self._sip_session = None
self._msrp_stream = None
self.end()
def _NH_SIPSessionNewProposal(self, notification):
if notification.data.originator == 'remote':
self._sip_session.reject_proposal()
def _NH_SIPSessionTransferNewIncoming(self, notification):
self._sip_session.reject_transfer(403)
def _NH_SIPSessionGotConferenceInfo(self, notification):
# Translate to XMPP payload
xmpp_manager = XMPPManager()
own_uri = FrozenURI(self.xmpp_identity.uri.user, self.xmpp_identity.uri.host)
conference_info = notification.data.conference_info
new_participants = set()
for user in conference_info.users:
user_uri = FrozenURI.parse(user.entity if user.entity.startswith(('sip:', 'sips:')) else 'sip:'+user.entity)
nickname = user.display_text.value if user.display_text else user.entity
new_participants.add((user_uri, nickname))
# Remove participants that are no longer in the room
for uri, nickname in self._participants - new_participants:
sender = Identity(FrozenURI(self.sip_identity.uri.user, self.sip_identity.uri.host, nickname))
stanza = MUCAvailabilityPresence(sender, self.xmpp_identity, available=False)
xmpp_manager.send_muc_stanza(stanza)
# Send presence for current participants
for uri, nickname in new_participants:
if uri == own_uri:
continue
sender = Identity(FrozenURI(self.sip_identity.uri.user, self.sip_identity.uri.host, nickname))
stanza = MUCAvailabilityPresence(sender, self.xmpp_identity, available=True)
stanza.jid = Identity(uri)
xmpp_manager.send_muc_stanza(stanza)
self._participants = new_participants
# Send own status last
sender = Identity(FrozenURI(self.sip_identity.uri.user, self.sip_identity.uri.host, self.nickname))
stanza = MUCAvailabilityPresence(sender, self.xmpp_identity, available=True)
stanza.jid = self.xmpp_identity
stanza.muc_statuses.append('110')
xmpp_manager.send_muc_stanza(stanza)
def _NH_ChatStreamGotMessage(self, notification):
# Notification is sent by the MSRP stream
if not self._xmpp_muc_session:
return
message = notification.data.message
content_type = message.content_type.lower()
if content_type not in ('text/plain', 'text/html'):
return
if content_type == 'text/plain':
html_body = None
body = message.content
else:
html_body = message.content
body = None
resource = message.sender.display_name or str(message.sender.uri)
sender = Identity(FrozenURI(self.sip_identity.uri.user, self.sip_identity.uri.host, resource))
self._xmpp_muc_session.send_message(sender, body, html_body, message_id='MUC.'+uuid.uuid4().hex)
self._msrp_stream.msrp_session.send_report(notification.data.chunk, 200, 'OK')
def _NH_ChatStreamDidSetNickname(self, notification):
# Notification is sent by the MSRP stream
nickname, stanza = self._pending_nicknames_map.pop(notification.data.message_id)
self.nickname = nickname
def _NH_ChatStreamDidNotSetNickname(self, notification):
# Notification is sent by the MSRP stream
nickname, stanza = self._pending_nicknames_map.pop(notification.data.message_id)
error_stanza = MUCErrorPresence.from_stanza(stanza, 'cancel', [('conflict', STANZAS_NS)])
xmpp_manager = XMPPManager()
xmpp_manager.send_muc_stanza(error_stanza)
def _NH_ChatStreamDidDeliverMessage(self, notification):
# Echo back the message to the sender
stanza = self._pending_messages_map.pop(notification.data.message_id)
stanza.sender, stanza.recipient = stanza.recipient, stanza.sender
stanza.sender.uri = FrozenURI(stanza.sender.uri.user, stanza.sender.uri.host, self.nickname)
xmpp_manager = XMPPManager()
xmpp_manager.send_muc_stanza(stanza)
def _NH_ChatStreamDidNotDeliverMessage(self, notification):
self._pending_messages_map.pop(notification.data.message_id)
def _NH_XMPPIncomingMucSessionDidEnd(self, notification):
notification.center.remove_observer(self, sender=self._xmpp_muc_session)
self._xmpp_muc_session = None
self.end()
def _NH_XMPPIncomingMucSessionGotMessage(self, notification):
if not self._sip_session:
return
message = notification.data.message
sender_uri = message.sender.uri.as_sip_uri()
del sender_uri.parameters['gr'] # no GRUU in CPIM From header
sender = ChatIdentity(sender_uri, display_name=self.nickname)
message_id = self._msrp_stream.send_message(message.body, 'text/plain', sender=sender)
self._pending_messages_map[message_id] = message
# Message will be echoed back to the sender on ChatStreamDidDeliverMessage
def _NH_XMPPIncomingMucSessionChangedNickname(self, notification):
if not self._sip_session:
return
nickname = notification.data.nickname
try:
message_id = self._msrp_stream.set_local_nickname(nickname)
except ChatStreamError:
return
self._pending_nicknames_map[message_id] = (nickname, notification.data.stanza)
diff --git a/sylk/applications/xmppgateway/presence.py b/sylk/applications/xmppgateway/presence.py
index 247f4d0..1d86a9e 100644
--- a/sylk/applications/xmppgateway/presence.py
+++ b/sylk/applications/xmppgateway/presence.py
@@ -1,514 +1,512 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
import hashlib
import random
from application.notification import IObserver, NotificationCenter
from application.python import Null, limit
from application.python.descriptor import WriteOnceAttribute
from eventlib import coros, proc
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import Engine, SIPURI, SIPCoreError
from sipsimple.core import ContactHeader, FromHeader, RouteHeader, ToHeader
from sipsimple.core import Subscription
from sipsimple.lookup import DNSLookup, DNSLookupError
from sipsimple.payloads import pidf, rpid, caps
from sipsimple.payloads import ParserError
from sipsimple.threading import run_in_twisted_thread
from sipsimple.threading.green import Command, run_in_green_thread
from sipsimple.util import ISOTimestamp
from time import time
from twisted.internet import reactor
from zope.interface import implements
from sylk.accounts import DefaultAccount
from sylk.applications.xmppgateway.configuration import XMPPGatewayConfig
from sylk.applications.xmppgateway.datatypes import Identity, FrozenURI, encode_resource
from sylk.applications.xmppgateway.logger import log
from sylk.applications.xmppgateway.util import format_uri
from sylk.applications.xmppgateway.xmpp.stanzas import AvailabilityPresence
from sylk.applications.xmppgateway.xmpp.subscription import XMPPSubscription, XMPPIncomingSubscription
from sylk.configuration import SIPConfig
__all__ = ['S2XPresenceHandler', 'X2SPresenceHandler']
class S2XPresenceHandler(object):
implements(IObserver)
sip_identity = WriteOnceAttribute()
xmpp_identity = WriteOnceAttribute()
def __init__(self, sip_identity, xmpp_identity):
self.ended = False
self._sip_subscriptions = []
self._stanza_cache = {}
self._pidf = None
self._xmpp_subscription = None
self.sip_identity = sip_identity
self.xmpp_identity = xmpp_identity
def start(self):
notification_center = NotificationCenter()
self._xmpp_subscription = XMPPSubscription(local_identity=self.sip_identity, remote_identity=self.xmpp_identity)
notification_center.add_observer(self, sender=self._xmpp_subscription)
self._xmpp_subscription.start()
notification_center.post_notification('S2XPresenceHandlerDidStart', sender=self)
def end(self):
if self.ended:
return
notification_center = NotificationCenter()
if self._xmpp_subscription is not None:
notification_center.remove_observer(self, sender=self._xmpp_subscription)
self._xmpp_subscription.end()
self._xmpp_subscription = None
while self._sip_subscriptions:
subscription = self._sip_subscriptions.pop()
notification_center.remove_observer(self, sender=subscription)
try:
subscription.end()
except SIPCoreError:
pass
self.ended = True
notification_center.post_notification('S2XPresenceHandlerDidEnd', sender=self)
def add_sip_subscription(self, subscription):
# If s subscription is received after the handle has ended but before
# S2XPresenceHandlerDidEnd has been processed we need to ignore it and wait for a retransmission
# which we will handle by creating a new S2XPresenceHandler
if self.ended:
return
self._sip_subscriptions.append(subscription)
NotificationCenter().add_observer(self, sender=subscription)
if self._xmpp_subscription.state == 'active':
pidf_doc = self._pidf
content_type = pidf.PIDFDocument.content_type if pidf_doc is not None else None
subscription.accept(content_type, pidf_doc)
else:
subscription.accept_pending()
if XMPPGatewayConfig.log_presence:
log.msg('SIP subscription from %s to %s added to presence flow 0x%x (%d subs)' % (format_uri(self.sip_identity.uri, 'sip'), format_uri(self.xmpp_identity.uri, 'xmpp'), id(self), len(self._sip_subscriptions)))
def _build_pidf(self):
if not self._stanza_cache:
self._pidf = None
return None
pidf_doc = pidf.PIDF(str(self.xmpp_identity))
uri = next(self._stanza_cache.iterkeys())
person = pidf.Person("PID-%s" % hashlib.md5("%s@%s" % (uri.user, uri.host)).hexdigest())
person.activities = rpid.Activities()
pidf_doc.add(person)
for stanza in self._stanza_cache.itervalues():
if not stanza.available:
status = pidf.Status('closed')
status.extended = 'offline'
else:
status = pidf.Status('open')
if stanza.show == 'away':
status.extended = 'away'
if 'away' not in person.activities:
person.activities.add('away')
elif stanza.show == 'xa':
status.extended = 'away'
if 'away' not in person.activities:
person.activities.add('away')
elif stanza.show == 'dnd':
status.extended = 'busy'
if 'busy' not in person.activities:
person.activities.add('busy')
else:
status.extended = 'available'
if stanza.sender.uri.resource:
resource = encode_resource(stanza.sender.uri.resource)
else:
# Workaround for clients not sending the resource under certain (unknown) circumstances
resource = hashlib.md5("%s@%s" % (uri.user, uri.host)).hexdigest()
service_id = "SID-%s" % resource
sip_uri = stanza.sender.uri.as_sip_uri()
sip_uri.parameters['gr'] = resource
sip_uri.parameters['xmpp'] = None
contact = pidf.Contact(str(sip_uri))
service = pidf.Service(service_id, status=status, contact=contact)
service.add(pidf.DeviceID(resource))
service.device_info = pidf.DeviceInfo(resource, description=stanza.sender.uri.resource)
service.timestamp = pidf.ServiceTimestamp(stanza.timestamp)
service.capabilities = caps.ServiceCapabilities(text=True, message=True)
for lang, note in stanza.statuses.iteritems():
service.notes.add(pidf.PIDFNote(note, lang=lang))
pidf_doc.add(service)
if not person.activities:
person.activities = None
self._pidf = pidf_doc.toxml()
return self._pidf
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPIncomingSubscriptionDidEnd(self, notification):
subscription = notification.sender
notification.center.remove_observer(self, sender=subscription)
self._sip_subscriptions.remove(subscription)
if XMPPGatewayConfig.log_presence:
log.msg('SIP subscription from %s to %s removed from presence flow 0x%x (%d subs)' % (format_uri(self.sip_identity.uri, 'sip'), format_uri(self.xmpp_identity.uri, 'xmpp'), id(self), len(self._sip_subscriptions)))
if not self._sip_subscriptions:
self.end()
def _NH_SIPIncomingSubscriptionNotifyDidFail(self, notification):
if XMPPGatewayConfig.log_presence:
log.msg('Sending SIP NOTIFY failed from %s to %s for presence flow 0x%x: %s (%s)' % (format_uri(self.xmpp_identity.uri, 'xmpp'), format_uri(self.sip_identity.uri, 'sip'), id(self), notification.data.code, notification.data.reason))
def _NH_SIPIncomingSubscriptionGotUnsubscribe(self, notification):
if XMPPGatewayConfig.log_presence:
log.msg('SIP subscription from %s to %s was terminated by user for presence flow 1x%x (%d subs)' % (format_uri(self.sip_identity.uri, 'sip'), format_uri(self.xmpp_identity.uri, 'xmpp'), id(self), len(self._sip_subscriptions)))
def _NH_SIPIncomingSubscriptionGotRefreshingSubscribe(self, notification):
if XMPPGatewayConfig.log_presence:
log.msg('SIP subscription from %s to %s was refreshed for presence flow 0x%x (%d subs)' % (format_uri(self.sip_identity.uri, 'sip'), format_uri(self.xmpp_identity.uri, 'xmpp'), id(self), len(self._sip_subscriptions)))
def _NH_SIPIncomingSubscriptionDidTimeout(self, notification):
if XMPPGatewayConfig.log_presence:
log.msg('SIP subscription from %s to %s timed out for presence flow 0x%x (%d subs)' % (format_uri(self.sip_identity.uri, 'sip'), format_uri(self.xmpp_identity.uri, 'xmpp'), id(self), len(self._sip_subscriptions)))
def _NH_XMPPSubscriptionChangedState(self, notification):
if notification.data.prev_state == 'subscribe_sent' and notification.data.state == 'active':
pidf_doc = self._pidf
content_type = pidf.PIDFDocument.content_type if pidf_doc is not None else None
for subscription in (subscription for subscription in self._sip_subscriptions if subscription.state == 'pending'):
subscription.accept(content_type, pidf_doc)
def _NH_XMPPSubscriptionGotNotify(self, notification):
stanza = notification.data.presence
self._stanza_cache[stanza.sender.uri] = stanza
stanza.timestamp = ISOTimestamp.now() # TODO: mirror the one in the stanza, if present
pidf_doc = self._build_pidf()
if XMPPGatewayConfig.log_presence:
log.msg('XMPP notification from %s to %s for presence flow 0x%x' % (format_uri(self.xmpp_identity.uri, 'xmpp'), format_uri(self.sip_identity.uri, 'sip'), id(self)))
for subscription in self._sip_subscriptions:
try:
subscription.push_content(pidf.PIDFDocument.content_type, pidf_doc)
except SIPCoreError, e:
if XMPPGatewayConfig.log_presence:
log.msg('Failed to send SIP NOTIFY from %s to %s for presence flow 0x%x: %s' % (format_uri(self.xmpp_identity.uri, 'xmpp'), format_uri(self.sip_identity.uri, 'sip'), id(self), e))
if not stanza.available:
# Only inform once about this device being unavailable
del self._stanza_cache[stanza.sender.uri]
def _NH_XMPPSubscriptionDidFail(self, notification):
notification.center.remove_observer(self, sender=self._xmpp_subscription)
self._xmpp_subscription = None
self.end()
_NH_XMPPSubscriptionDidEnd = _NH_XMPPSubscriptionDidFail
class InterruptSubscription(Exception): pass
class TerminateSubscription(Exception): pass
class SubscriptionError(Exception):
def __init__(self, error, timeout, refresh_interval=None, fatal=False):
self.error = error
self.refresh_interval = refresh_interval
self.timeout = timeout
self.fatal = fatal
class SIPSubscriptionDidFail(Exception):
def __init__(self, data):
self.data = data
class X2SPresenceHandler(object):
implements(IObserver)
sip_identity = WriteOnceAttribute()
xmpp_identity = WriteOnceAttribute()
def __init__(self, sip_identity, xmpp_identity):
self.ended = False
self.sip_identity = sip_identity
self.xmpp_identity = xmpp_identity
self.subscribed = False
self._command_proc = None
self._command_channel = coros.queue()
self._data_channel = coros.queue()
self._sip_subscription = None
self._sip_subscription_proc = None
self._sip_subscription_timer = None
self._xmpp_subscription = None
def start(self):
notification_center = NotificationCenter()
self._xmpp_subscription = XMPPIncomingSubscription(local_identity=self.sip_identity, remote_identity=self.xmpp_identity)
notification_center.add_observer(self, sender=self._xmpp_subscription)
self._xmpp_subscription.start()
self._command_proc = proc.spawn(self._run)
self._subscribe_sip()
notification_center.post_notification('X2SPresenceHandlerDidStart', sender=self)
def end(self):
if self.ended:
return
notification_center = NotificationCenter()
if self._xmpp_subscription is not None:
notification_center.remove_observer(self, sender=self._xmpp_subscription)
self._xmpp_subscription.end()
self._xmpp_subscription = None
if self._sip_subscription:
self._unsubscribe_sip()
self.ended = True
notification_center.post_notification('X2SPresenceHandlerDidEnd', sender=self)
@run_in_green_thread
def _subscribe_sip(self):
command = Command('subscribe')
self._command_channel.send(command)
@run_in_green_thread
def _unsubscribe_sip(self):
command = Command('unsubscribe')
self._command_channel.send(command)
command.wait()
self._command_proc.kill()
self._command_proc = None
def _run(self):
while True:
command = self._command_channel.wait()
handler = getattr(self, '_CH_%s' % command.name)
handler(command)
def _CH_subscribe(self, command):
if self._sip_subscription_timer is not None and self._sip_subscription_timer.active():
self._sip_subscription_timer.cancel()
self._sip_subscription_timer = None
if self._sip_subscription_proc is not None:
subscription_proc = self._sip_subscription_proc
subscription_proc.kill(InterruptSubscription)
subscription_proc.wait()
self._sip_subscription_proc = proc.spawn(self._sip_subscription_handler, command)
def _CH_unsubscribe(self, command):
# Cancel any timer which would restart the subscription process
if self._sip_subscription_timer is not None and self._sip_subscription_timer.active():
self._sip_subscription_timer.cancel()
self._sip_subscription_timer = None
if self._sip_subscription_proc is not None:
subscription_proc = self._sip_subscription_proc
subscription_proc.kill(TerminateSubscription)
subscription_proc.wait()
self._sip_subscription_proc = None
command.signal()
def _process_pidf(self, body):
try:
pidf_doc = pidf.PIDF.parse(body)
except ParserError, e:
log.warn('Error parsing PIDF document: %s' % e)
return
# Build XML stanzas out of PIDF documents
try:
person = next(p for p in pidf_doc.persons)
except StopIteration:
person = None
for service in pidf_doc.services:
sip_contact = self.sip_identity.uri.as_sip_uri()
if service.device_info is not None:
sip_contact.parameters['gr'] = 'urn:uuid:%s' % service.device_info.id
else:
sip_contact.parameters['gr'] = service.id
sender = Identity(FrozenURI.parse(sip_contact))
if service.status.extended is not None:
available = service.status.extended != 'offline'
else:
available = service.status.basic == 'open'
stanza = AvailabilityPresence(sender, self.xmpp_identity, available)
for note in service.notes:
stanza.statuses[note.lang] = note
if service.status.extended is not None:
if service.status.extended == 'away':
stanza.show = 'away'
elif service.status.extended == 'busy':
stanza.show = 'dnd'
elif person is not None and person.activities is not None:
activities = set(list(person.activities))
if 'away' in activities:
stanza.show = 'away'
elif set(('holiday', 'vacation')).intersection(activities):
stanza.show = 'xa'
elif 'busy' in activities:
stanza.show = 'dnd'
self._xmpp_subscription.send_presence(stanza)
def _sip_subscription_handler(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
account = DefaultAccount()
refresh_interval = getattr(command, 'refresh_interval', None) or account.sip.subscribe_interval
try:
# Lookup routes
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
else:
uri = SIPURI(host=self.sip_identity.uri.as_sip_uri().host)
lookup = DNSLookup()
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError, e:
timeout = random.uniform(15, 30)
raise SubscriptionError(error='DNS lookup failed: %s' % e, timeout=timeout)
timeout = time() + 30
for route in routes:
remaining_time = timeout - time()
if remaining_time > 0:
transport = route.transport
parameters = {} if transport=='udp' else {'transport': transport}
contact_uri = SIPURI(user=account.contact.username, host=SIPConfig.local_ip.normalized, port=getattr(Engine(), '%s_port' % transport), parameters=parameters)
subscription_uri = self.sip_identity.uri.as_sip_uri()
subscription = Subscription(subscription_uri, FromHeader(self.xmpp_identity.uri.as_sip_uri()),
ToHeader(subscription_uri),
ContactHeader(contact_uri),
'presence',
RouteHeader(route.uri),
refresh=refresh_interval)
notification_center.add_observer(self, sender=subscription)
try:
subscription.subscribe(timeout=limit(remaining_time, min=1, max=5))
except SIPCoreError:
notification_center.remove_observer(self, sender=subscription)
raise SubscriptionError(error='Internal error', timeout=5)
self._sip_subscription = subscription
try:
while True:
notification = self._data_channel.wait()
if notification.sender is subscription and notification.name == 'SIPSubscriptionDidStart':
break
except SIPSubscriptionDidFail, e:
notification_center.remove_observer(self, sender=subscription)
self._sip_subscription = None
if e.data.code == 407:
# Authentication failed, so retry the subscription in some time
raise SubscriptionError(error='Authentication failed', timeout=random.uniform(60, 120))
elif e.data.code == 403:
# Forbidden
raise SubscriptionError(error='Forbidden', timeout=None, fatal=True)
elif e.data.code == 423:
# Get the value of the Min-Expires header
if e.data.min_expires is not None and e.data.min_expires > refresh_interval:
interval = e.data.min_expires
else:
interval = None
raise SubscriptionError(error='Interval too short', timeout=random.uniform(60, 120), refresh_interval=interval)
elif e.data.code in (405, 406, 489):
raise SubscriptionError(error='Method or event not supported', timeout=None, fatal=True)
elif e.data.code == 1400:
raise SubscriptionError(error=e.data.reason, timeout=None, fatal=True)
else:
# Otherwise just try the next route
continue
else:
self.subscribed = True
command.signal()
break
else:
# There are no more routes to try, give up
raise SubscriptionError(error='No more routes to try', timeout=None, fatal=True)
# At this point it is subscribed. Handle notifications and ending/failures.
try:
while True:
notification = self._data_channel.wait()
if notification.sender is not self._sip_subscription:
continue
if self._xmpp_subscription is None:
continue
if notification.name == 'SIPSubscriptionGotNotify':
if notification.data.event == 'presence':
subscription_state = notification.data.headers.get('Subscription-State').state
if subscription_state == 'active' and self._xmpp_subscription.state != 'active':
self._xmpp_subscription.accept()
elif subscription_state == 'pending' and self._xmpp_subscription.state == 'active':
# The state went from active to pending, hide the presence state?
pass
if notification.data.body:
if XMPPGatewayConfig.log_presence:
log.msg('SIP NOTIFY from %s to %s' % (format_uri(self.sip_identity.uri, 'sip'), format_uri(self.xmpp_identity.uri, 'xmpp')))
self._process_pidf(notification.data.body)
elif notification.name == 'SIPSubscriptionDidEnd':
break
except SIPSubscriptionDidFail, e:
if e.data.code == 0 and e.data.reason == 'rejected':
self._xmpp_subscription.reject()
else:
self._command_channel.send(Command('subscribe'))
notification_center.remove_observer(self, sender=self._sip_subscription)
except InterruptSubscription, e:
if not self.subscribed:
command.signal(e)
if self._sip_subscription is not None:
notification_center.remove_observer(self, sender=self._sip_subscription)
try:
self._sip_subscription.end(timeout=2)
except SIPCoreError:
pass
except TerminateSubscription, e:
if not self.subscribed:
command.signal(e)
if self._sip_subscription is not None:
try:
self._sip_subscription.end(timeout=2)
except SIPCoreError:
pass
else:
try:
while True:
notification = self._data_channel.wait()
if notification.sender is self._sip_subscription and notification.name == 'SIPSubscriptionDidEnd':
break
except SIPSubscriptionDidFail:
pass
finally:
notification_center.remove_observer(self, sender=self._sip_subscription)
except SubscriptionError, e:
if not e.fatal:
self._sip_subscription_timer = reactor.callLater(e.timeout, self._command_channel.send, Command('subscribe', command.event, refresh_interval=e.refresh_interval))
finally:
self.subscribed = False
self._sip_subscription = None
self._sip_subscription_proc = None
reactor.callLater(0, self.end)
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSubscriptionDidStart(self, notification):
self._data_channel.send(notification)
def _NH_SIPSubscriptionDidEnd(self, notification):
self._data_channel.send(notification)
def _NH_SIPSubscriptionDidFail(self, notification):
self._data_channel.send_exception(SIPSubscriptionDidFail(notification.data))
def _NH_SIPSubscriptionGotNotify(self, notification):
self._data_channel.send(notification)
def _NH_XMPPIncomingSubscriptionGotUnsubscribe(self, notification):
self.end()
def _NH_XMPPIncomingSubscriptionGotSubscribe(self, notification):
if self._sip_subscription is not None and self._sip_subscription.state.lower() == 'active':
self._xmpp_subscription.accept()
_NH_XMPPIncomingSubscriptionGotProbe = _NH_XMPPIncomingSubscriptionGotSubscribe
diff --git a/sylk/applications/xmppgateway/util.py b/sylk/applications/xmppgateway/util.py
index 720d4a7..a879317 100644
--- a/sylk/applications/xmppgateway/util.py
+++ b/sylk/applications/xmppgateway/util.py
@@ -1,32 +1,30 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
import lxml.html
import lxml.html.clean
__all__ = ['html2text', 'text2html', 'format_uri']
def html2text(data):
try:
doc = lxml.html.document_fromstring(data)
cleaner = lxml.html.clean.Cleaner(style=True)
doc = cleaner.clean_html(doc)
return doc.text_content().strip('\n')
except Exception:
return ''
xhtml_im_template = """
%(data)s
"""
def text2html(data):
return xhtml_im_template % {'data': data}
def format_uri(uri, scheme=''):
return '%s%s@%s' % ('' if not scheme else scheme+':', uri.user, uri.host)
diff --git a/sylk/applications/xmppgateway/xmpp/__init__.py b/sylk/applications/xmppgateway/xmpp/__init__.py
index 2a861e1..2d78d73 100644
--- a/sylk/applications/xmppgateway/xmpp/__init__.py
+++ b/sylk/applications/xmppgateway/xmpp/__init__.py
@@ -1,325 +1,323 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.types import Singleton
from twisted.internet import reactor
from wokkel.disco import DiscoClientProtocol
from wokkel.generic import FallbackHandler, VersionHandler
from wokkel.ping import PingHandler
from wokkel.server import ServerService
from zope.interface import implements
from sylk import __version__ as SYLK_VERSION
from sylk.applications.xmppgateway.configuration import XMPPGatewayConfig
from sylk.applications.xmppgateway.datatypes import FrozenURI
from sylk.applications.xmppgateway.logger import log
from sylk.applications.xmppgateway.xmpp.jingle.session import JingleSession, JingleSessionManager
from sylk.applications.xmppgateway.xmpp.protocols import DiscoProtocol, JingleProtocol, MessageProtocol, MUCServerProtocol, MUCPresenceProtocol, PresenceProtocol
from sylk.applications.xmppgateway.xmpp.server import SylkInternalComponent, SylkRouter, SylkS2SServerFactory, xmpp_logger
from sylk.applications.xmppgateway.xmpp.session import XMPPChatSessionManager, XMPPMucSessionManager
from sylk.applications.xmppgateway.xmpp.subscription import XMPPSubscriptionManager
class XMPPManager(object):
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
config = XMPPGatewayConfig
self.stopped = False
self.domains = set(config.domains)
self.muc_domains = set(['%s.%s' % (config.muc_prefix, domain) for domain in self.domains])
router = SylkRouter()
self._server_service = ServerService(router)
self._server_service.domains = self.domains | self.muc_domains
self._server_service.logTraffic = False # done manually
self._s2s_factory = SylkS2SServerFactory(self._server_service)
self._s2s_factory.logTraffic = False # done manually
# Setup internal components
self._internal_component = SylkInternalComponent(router)
self._internal_component.domains = self.domains
self._internal_component.manager = self
self._muc_component = SylkInternalComponent(router)
self._muc_component.domains = self.muc_domains
self._muc_component.manager = self
# Setup protocols
self.message_protocol = MessageProtocol()
self.message_protocol.setHandlerParent(self._internal_component)
self.presence_protocol = PresenceProtocol()
self.presence_protocol.setHandlerParent(self._internal_component)
self.disco_protocol = DiscoProtocol()
self.disco_protocol.setHandlerParent(self._internal_component)
self.disco_client_protocol = DiscoClientProtocol()
self.disco_client_protocol.setHandlerParent(self._internal_component)
self.muc_protocol = MUCServerProtocol()
self.muc_protocol.setHandlerParent(self._muc_component)
self.muc_presence_protocol = MUCPresenceProtocol()
self.muc_presence_protocol.setHandlerParent(self._muc_component)
self.disco_muc_protocol = DiscoProtocol()
self.disco_muc_protocol.setHandlerParent(self._muc_component)
self.version_protocol = VersionHandler('SylkServer', SYLK_VERSION)
self.version_protocol.setHandlerParent(self._internal_component)
self.fallback_protocol = FallbackHandler()
self.fallback_protocol.setHandlerParent(self._internal_component)
self.fallback_muc_protocol = FallbackHandler()
self.fallback_muc_protocol.setHandlerParent(self._muc_component)
self.ping_protocol = PingHandler()
self.ping_protocol.setHandlerParent(self._internal_component)
self.jingle_protocol = JingleProtocol()
self.jingle_protocol.setHandlerParent(self._internal_component)
self.jingle_coin_protocol = JingleProtocol()
self.jingle_coin_protocol.setHandlerParent(self._muc_component)
self._s2s_listener = None
self.chat_session_manager = XMPPChatSessionManager()
self.muc_session_manager = XMPPMucSessionManager()
self.subscription_manager = XMPPSubscriptionManager()
self.jingle_session_manager = JingleSessionManager()
def start(self):
self.stopped = False
xmpp_logger.start()
config = XMPPGatewayConfig
if config.trace_xmpp and xmpp_logger._xmpptrace_filename is not None:
log.msg('Logging XMPP trace to file "%s"' % xmpp_logger._xmpptrace_filename)
self._s2s_listener = reactor.listenTCP(config.local_port, self._s2s_factory, interface=config.local_ip)
listen_address = self._s2s_listener.getHost()
log.msg("XMPP listener started on %s:%d" % (listen_address.host, listen_address.port))
self.chat_session_manager.start()
self.muc_session_manager.start()
self.subscription_manager.start()
self.jingle_session_manager.start()
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self._internal_component)
notification_center.add_observer(self, sender=self._muc_component)
self._internal_component.startService()
self._muc_component.startService()
def stop(self):
self.stopped = True
self._s2s_listener.stopListening()
self.jingle_session_manager.stop()
self.subscription_manager.stop()
self.muc_session_manager.stop()
self.chat_session_manager.stop()
self._internal_component.stopService()
self._muc_component.stopService()
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=self._internal_component)
notification_center.remove_observer(self, sender=self._muc_component)
xmpp_logger.stop()
def send_stanza(self, stanza):
if self.stopped:
return
self._internal_component.send(stanza.to_xml_element())
def send_muc_stanza(self, stanza):
if self.stopped:
return
self._muc_component.send(stanza.to_xml_element())
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
# Process message stanzas
def _NH_XMPPGotChatMessage(self, notification):
message = notification.data.message
try:
session = self.chat_session_manager.sessions[(message.recipient.uri, message.sender.uri)]
except KeyError:
notification.center.post_notification('XMPPGotChatMessage', sender=self, data=notification.data)
else:
session.channel.send(message)
def _NH_XMPPGotNormalMessage(self, notification):
notification.center.post_notification('XMPPGotNormalMessage', sender=self, data=notification.data)
def _NH_XMPPGotComposingIndication(self, notification):
composing_indication = notification.data.composing_indication
try:
session = self.chat_session_manager.sessions[(composing_indication.recipient.uri, composing_indication.sender.uri)]
except KeyError:
notification.center.post_notification('XMPPGotComposingIndication', sender=self, data=notification.data)
else:
session.channel.send(composing_indication)
def _NH_XMPPGotErrorMessage(self, notification):
error_message = notification.data.error_message
try:
session = self.chat_session_manager.sessions[(error_message.recipient.uri, error_message.sender.uri)]
except KeyError:
notification.center.post_notification('XMPPGotErrorMessage', sender=self, data=notification.data)
else:
session.channel.send(error_message)
def _NH_XMPPGotReceipt(self, notification):
receipt = notification.data.receipt
try:
session = self.chat_session_manager.sessions[(receipt.recipient.uri, receipt.sender.uri)]
except KeyError:
pass
else:
session.channel.send(receipt)
# Process presence stanzas
def _NH_XMPPGotPresenceAvailability(self, notification):
stanza = notification.data.presence_stanza
if stanza.recipient.uri.resource is not None:
# Skip directed presence
return
sender_uri = stanza.sender.uri
sender_uri_bare = FrozenURI(sender_uri.user, sender_uri.host)
try:
subscription = self.subscription_manager.outgoing_subscriptions[(stanza.recipient.uri, sender_uri_bare)]
except KeyError:
# Ignore incoming presence stanzas if there is no subscription
pass
else:
subscription.channel.send(stanza)
def _NH_XMPPGotPresenceSubscriptionStatus(self, notification):
stanza = notification.data.presence_stanza
if stanza.sender.uri.resource is not None or stanza.recipient.uri.resource is not None:
# Skip directed presence
return
if stanza.type in ('subscribed', 'unsubscribed'):
try:
subscription = self.subscription_manager.outgoing_subscriptions[(stanza.recipient.uri, stanza.sender.uri)]
except KeyError:
pass
else:
subscription.channel.send(stanza)
elif stanza.type in ('subscribe', 'unsubscribe'):
try:
subscription = self.subscription_manager.incoming_subscriptions[(stanza.recipient.uri, stanza.sender.uri)]
except KeyError:
if stanza.type == 'subscribe':
notification.center.post_notification('XMPPGotPresenceSubscriptionRequest', sender=self, data=NotificationData(stanza=stanza))
else:
subscription.channel.send(stanza)
def _NH_XMPPGotPresenceProbe(self, notification):
stanza = notification.data.presence_stanza
if stanza.recipient.uri.resource is not None:
# Skip directed presence
return
sender_uri = stanza.sender.uri
sender_uri_bare = FrozenURI(sender_uri.user, sender_uri.host)
try:
subscription = self.subscription_manager.incoming_subscriptions[(stanza.recipient.uri, sender_uri_bare)]
except KeyError:
notification.center.post_notification('XMPPGotPresenceSubscriptionRequest', sender=self, data=NotificationData(stanza=stanza))
else:
subscription.channel.send(stanza)
# Process muc stanzas
def _NH_XMPPMucGotGroupChat(self, notification):
message = notification.data.message
muc_uri = FrozenURI(message.recipient.uri.user, message.recipient.uri.host)
try:
session = self.muc_session_manager.incoming[(muc_uri, message.sender.uri)]
except KeyError:
# Ignore groupchat messages if there was no session created
pass
else:
session.channel.send(message)
def _NH_XMPPMucGotPresenceAvailability(self, notification):
stanza = notification.data.presence_stanza
if not stanza.sender.uri.resource:
return
muc_uri = FrozenURI(stanza.recipient.uri.user, stanza.recipient.uri.host)
try:
session = self.muc_session_manager.incoming[(muc_uri, stanza.sender.uri)]
except KeyError:
if stanza.available:
notification.center.post_notification('XMPPGotMucJoinRequest', sender=self, data=NotificationData(stanza=stanza))
else:
notification.center.post_notification('XMPPGotMucLeaveRequest', sender=self, data=NotificationData(stanza=stanza))
else:
session.channel.send(stanza)
def _NH_XMPPMucGotInvitation(self, notification):
invitation = notification.data.invitation
data = NotificationData(sender=invitation.sender, recipient=invitation.recipient, participant=invitation.invited_user)
notification.center.post_notification('XMPPGotMucAddParticipantRequest', sender=self, data=data)
# Jingle
def _NH_XMPPGotJingleSessionInitiate(self, notification):
stanza = notification.data.stanza
try:
self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
session = JingleSession(notification.data.protocol)
session.init_incoming(stanza)
session.send_ring_indication()
def _NH_XMPPGotJingleSessionTerminate(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
def _NH_XMPPGotJingleSessionInfo(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
def _NH_XMPPGotJingleSessionAccept(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
def _NH_XMPPGotJingleDescriptionInfo(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
def _NH_XMPPGotJingleTransportInfo(self, notification):
stanza = notification.data.stanza
try:
session = self.jingle_session_manager.sessions[stanza.jingle.sid]
except KeyError:
return
session.handle_notification(notification)
diff --git a/sylk/applications/xmppgateway/xmpp/jingle/session.py b/sylk/applications/xmppgateway/xmpp/jingle/session.py
index 5172689..462db95 100644
--- a/sylk/applications/xmppgateway/xmpp/jingle/session.py
+++ b/sylk/applications/xmppgateway/xmpp/jingle/session.py
@@ -1,808 +1,806 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
import random
import string
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.types import Singleton
from cStringIO import StringIO
from datetime import datetime
from eventlib import api, coros, proc
from eventlib.twistedutil import block_on
from lxml import etree
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import SDPSession, SDPMediaStream, SDPConnection, SDPNegotiator
from sipsimple.core import SIPCoreError
from sipsimple.threading import run_in_twisted_thread
from twisted.internet import reactor
from twisted.words.protocols.jabber.error import StanzaError
from twisted.words.protocols.jabber.xmlstream import TimeoutError as IqTimeoutError
from zope.interface import implements
from sylk.accounts import DefaultAccount
from sylk.applications.xmppgateway.datatypes import Identity, FrozenURI
from sylk.applications.xmppgateway.xmpp.jingle.streams import MediaStreamRegistry, InvalidStreamError, UnknownStreamError
from sylk.applications.xmppgateway.xmpp.jingle.util import jingle_to_sdp, sdp_to_jingle
from sylk.applications.xmppgateway.xmpp.stanzas import jingle
from sylk.configuration import SIPConfig
def random_id():
return ''.join(random.choice(string.ascii_letters+string.digits) for x in xrange(32))
class MediaStreamDidFailError(Exception):
def __init__(self, stream, data):
self.stream = stream
self.data = data
class MediaStreamDidNotInitializeError(Exception):
def __init__(self, stream, data):
self.stream = stream
self.data = data
class Operation(object):
__params__ = ()
def __init__(self, **params):
for name, value in params.iteritems():
setattr(self, name, value)
for param in set(self.__params__).difference(params):
raise ValueError("missing operation parameter: '%s'" % param)
self.channel = coros.queue()
class AcceptOperation(Operation):
__params__ = ('streams', 'is_focus')
class SendRingIndicationOperation(Operation):
__params__ = ()
class RejectOperation(Operation):
__params__ = ('reason',)
class EndOperation(Operation):
__params__ = ()
class HoldOperation(Operation):
__params__ = ()
class UnholdOperation(Operation):
__params__ = ()
class ProcessRemoteOperation(Operation):
__params__ = ('notification',)
class ConnectOperation(Operation):
__params__ = ('sender', 'recipient', 'streams', 'is_focus')
class SendConferenceInfoOperation(Operation):
__params__ = ('xml',)
class JingleSession(object):
implements(IObserver)
jingle_stanza_timeout = 3
media_stream_timeout = 15
def __init__(self, protocol):
self.account = DefaultAccount()
self._protocol = protocol
self._id = None
self._local_identity = None
self._remote_identity = None
self._local_jid = None
self._remote_jid = None
self._channel = coros.queue()
self._current_operation = None
self._proc = proc.spawn(self._run)
self._timer = None
self._sdp_negotiator = None
self._pending_transport_info_stanzas = []
self.direction = None
self.state = None
self.streams = None
self.proposed_streams = None
self.start_time = None
self.end_time = None
self.on_hold = False
self.local_focus = False
def init_incoming(self, stanza):
self._id = stanza.jingle.sid
self._local_identity = Identity(FrozenURI.parse(stanza.recipient))
self._remote_identity = Identity(FrozenURI.parse(stanza.sender))
self._local_jid = self._local_identity.uri.as_xmpp_jid()
self._remote_jid = self._remote_identity.uri.as_xmpp_jid()
remote_sdp = jingle_to_sdp(stanza.jingle)
try:
self._sdp_negotiator = SDPNegotiator.create_with_remote_offer(remote_sdp)
except SIPCoreError, e:
self._fail(originator='local', reason='general-error', description=str(e))
return
self.proposed_streams = []
for index, media_stream in enumerate(remote_sdp.media):
if media_stream.port != 0:
for stream_type in MediaStreamRegistry():
try:
stream = stream_type.new_from_sdp(self, remote_sdp, index)
except InvalidStreamError:
break
except UnknownStreamError:
continue
else:
stream.index = index
self.proposed_streams.append(stream)
break
if self.proposed_streams:
self.direction = 'incoming'
self.state = 'incoming'
NotificationCenter().post_notification('JingleSessionNewIncoming', sender=self, data=NotificationData(streams=self.proposed_streams))
else:
self._fail(originator='local', reason='unsupported-applications')
def connect(self, sender_identity, recipient_identity, streams, is_focus=False):
self._schedule_operation(ConnectOperation(sender=sender_identity, recipient=recipient_identity, streams=streams, is_focus=is_focus))
def send_ring_indication(self):
self._schedule_operation(SendRingIndicationOperation())
def accept(self, streams, is_focus=False):
self._schedule_operation(AcceptOperation(streams=streams, is_focus=is_focus))
def reject(self, reason='busy'):
self._schedule_operation(RejectOperation(reason=reason))
def hold(self):
self._schedule_operation(HoldOperation())
def unhold(self):
self._schedule_operation(UnholdOperation())
def end(self):
self._schedule_operation(EndOperation())
def add_stream(self):
raise NotImplementedError
def remove_stream(self):
raise NotImplementedError
@property
def id(self):
return self._id
@property
def local_identity(self):
return self._local_identity
@property
def remote_identity(self):
return self._remote_identity
@run_in_twisted_thread
def _send_conference_info(self, xml):
# This function is not meant for users to call, entities with knowledge about JingleSession
# internals will call it, such as the MediaSessionHandler
self._schedule_operation(SendConferenceInfoOperation(xml=xml))
def _send_stanza(self, stanza):
if self.direction == 'incoming':
stanza.jingle.initiator = unicode(self._remote_jid)
stanza.jingle.responder = unicode(self._local_jid)
else:
stanza.jingle.initiator = unicode(self._local_jid)
stanza.jingle.responder = unicode(self._remote_jid)
stanza.timeout = self.jingle_stanza_timeout
return self._protocol.request(stanza)
def _fail(self, originator='local', reason='general-error', description=None):
reason = jingle.Reason(jingle.ReasonType(reason), text=description)
stanza = self._protocol.sessionTerminate(self._local_jid, self._remote_jid, self._id, reason)
self._send_stanza(stanza)
self.state = 'terminated'
failure_str = '%s%s' % (reason, ' %s' % description if description else '')
NotificationCenter().post_notification('JingleSessionDidFail', sender=self, data=NotificationData(originator='local', reason=failure_str))
self._channel.send_exception(proc.ProcExit)
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_RTPStreamDidEnableEncryption(self, notification):
if notification.sender.type != 'audio':
return
audio_stream = notification.sender
if audio_stream.encryption.type == 'ZRTP':
# start ZRTP on the video stream, if applicable
try:
video_stream = next(stream for stream in self.streams or [] if stream.type=='video')
except StopIteration:
return
if video_stream.encryption.type == 'ZRTP' and not video_stream.encryption.active:
video_stream.encryption.zrtp._enable(audio_stream)
def _NH_MediaStreamDidStart(self, notification):
stream = notification.sender
if stream.type == 'audio' and stream.encryption.type == 'ZRTP':
stream.encryption.zrtp._enable()
elif stream.type == 'video' and stream.encryption.type == 'ZRTP':
# start ZRTP on the video stream, if applicable
try:
audio_stream = next(stream for stream in self.streams or [] if stream.type=='audio')
except StopIteration:
pass
else:
if audio_stream.encryption.type == 'ZRTP' and audio_stream.encryption.active:
stream.encryption.zrtp._enable(audio_stream)
if self._current_operation is not None:
self._current_operation.channel.send(notification)
def _NH_MediaStreamDidInitialize(self, notification):
if self._current_operation is not None:
self._current_operation.channel.send(notification)
def _NH_MediaStreamDidNotInitialize(self, notification):
if self._current_operation is not None:
self._current_operation.channel.send_exception(MediaStreamDidNotInitializeError(notification.sender, notification.data))
def _NH_MediaStreamDidFail(self, notification):
if self._current_operation is not None:
self._current_operation.channel.send_exception(MediaStreamDidFailError(notification.sender, notification.data))
else:
self.end()
def _NH_XMPPGotJingleSessionAccept(self, notification):
self._schedule_operation(ProcessRemoteOperation(notification=notification))
def _NH_XMPPGotJingleSessionTerminate(self, notification):
self._schedule_operation(ProcessRemoteOperation(notification=notification))
def _NH_XMPPGotJingleSessionInfo(self, notification):
self._schedule_operation(ProcessRemoteOperation(notification=notification))
def _NH_XMPPGotJingleDescriptionInfo(self, notification):
self._schedule_operation(ProcessRemoteOperation(notification=notification))
def _NH_XMPPGotJingleTransportInfo(self, notification):
self._schedule_operation(ProcessRemoteOperation(notification=notification))
# Operation handling
@run_in_twisted_thread
def _schedule_operation(self, operation):
self._channel.send(operation)
def _run(self):
while True:
self._current_operation = op = self._channel.wait()
try:
handler = getattr(self, '_OH_%s' % op.__class__.__name__)
handler(op)
except BaseException:
self._proc = None
raise
finally:
self._current_operation = None
def _OH_AcceptOperation(self, operation):
if self.state != 'incoming':
return
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
streams = operation.streams
for stream in self.proposed_streams:
if stream in streams:
notification_center.add_observer(self, sender=stream)
stream.initialize(self, direction='incoming')
try:
wait_count = len(self.proposed_streams)
while wait_count > 0:
notification = operation.channel.wait()
if notification.name == 'MediaStreamDidInitialize':
wait_count -= 1
remote_sdp = self._sdp_negotiator.current_remote
local_ip = SIPConfig.local_ip.normalized
local_sdp = SDPSession(local_ip, connection=SDPConnection(local_ip), name=settings.user_agent)
stream_map = dict((stream.index, stream) for stream in self.proposed_streams)
for index, media in enumerate(remote_sdp.media):
stream = stream_map.get(index, None)
if stream is not None:
media = stream.get_local_media(remote_sdp=remote_sdp, index=index)
else:
media = SDPMediaStream.new(media)
media.port = 0
media.attributes = []
local_sdp.media.append(media)
try:
self._sdp_negotiator.set_local_answer(local_sdp)
self._sdp_negotiator.negotiate()
except SIPCoreError, e:
self._fail(originator='local', reason='incompatible-parameters', description=str(e))
return
self.local_focus = operation.is_focus
notification_center.post_notification('JingleSessionWillStart', sender=self)
# Get active SDPs (negotiator may make changes)
local_sdp = self._sdp_negotiator.active_local
remote_sdp = self._sdp_negotiator.active_remote
# Build the payload and send it over
payload = sdp_to_jingle(local_sdp)
payload.sid = self._id
if self.local_focus:
payload.conference_info = jingle.ConferenceInfo(True)
stanza = self._protocol.sessionAccept(self._local_jid, self._remote_jid, payload)
d = self._send_stanza(stanza)
block_on(d)
wait_count = 0
stream_map = dict((stream.index, stream) for stream in self.proposed_streams)
for index, local_media in enumerate(local_sdp.media):
remote_media = remote_sdp.media[index]
stream = stream_map.get(index, None)
if stream is not None:
if remote_media.port:
wait_count += 1
stream.start(local_sdp, remote_sdp, index)
else:
notification_center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
removed_streams = [stream for stream in self.proposed_streams if stream.index >= len(local_sdp.media)]
for stream in removed_streams:
notification_center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
with api.timeout(self.media_stream_timeout):
while wait_count > 0:
notification = operation.channel.wait()
if notification.name == 'MediaStreamDidStart':
wait_count -= 1
except (MediaStreamDidNotInitializeError, MediaStreamDidFailError, api.TimeoutError, IqTimeoutError, StanzaError), e:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
if isinstance(e, api.TimeoutError):
error = 'media stream timed out while starting'
elif isinstance(e, IqTimeoutError):
error = 'timeout sending IQ stanza'
elif isinstance(e, StanzaError):
error = str(e.condition)
else:
error = 'media stream failed: %s' % e.data.reason
self._fail(originator='local', reason='failed-application', description=error)
else:
self.state = 'connected'
self.streams = self.proposed_streams
self.proposed_streams = None
self.start_time = datetime.now()
notification_center.post_notification('JingleSessionDidStart', self, NotificationData(streams=self.streams))
def _OH_ConnectOperation(self, operation):
if self.state is not None:
return
settings = SIPSimpleSettings()
notification_center = NotificationCenter()
self.direction = 'outgoing'
self.state = 'connecting'
self.proposed_streams = operation.streams
self.local_focus = operation.is_focus
self._id = random_id()
self._local_identity = operation.sender
self._remote_identity = operation.recipient
self._local_jid = self._local_identity.uri.as_xmpp_jid()
self._remote_jid = self._remote_identity.uri.as_xmpp_jid()
notification_center.post_notification('JingleSessionNewOutgoing', self, NotificationData(streams=operation.streams))
for stream in self.proposed_streams:
notification_center.add_observer(self, sender=stream)
stream.initialize(self, direction='outgoing')
try:
wait_count = len(self.proposed_streams)
while wait_count > 0:
notification = operation.channel.wait()
if notification.name == 'MediaStreamDidInitialize':
wait_count -= 1
# Build local SDP and negotiator
local_ip = SIPConfig.local_ip.normalized
local_sdp = SDPSession(local_ip, connection=SDPConnection(local_ip), name=settings.user_agent)
for index, stream in enumerate(self.proposed_streams):
stream.index = index
media = stream.get_local_media(remote_sdp=None, index=index)
local_sdp.media.append(media)
self._sdp_negotiator = SDPNegotiator.create_with_local_offer(local_sdp)
# Build the payload and send it over
payload = sdp_to_jingle(local_sdp)
payload.sid = self._id
if self.local_focus:
payload.conference_info = jingle.ConferenceInfo(True)
stanza = self._protocol.sessionInitiate(self._local_jid, self._remote_jid, payload)
d = self._send_stanza(stanza)
block_on(d)
except (MediaStreamDidNotInitializeError, MediaStreamDidFailError, IqTimeoutError, StanzaError, SIPCoreError), e:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
if isinstance(e, IqTimeoutError):
error = 'timeout sending IQ stanza'
elif isinstance(e, StanzaError):
error = str(e.condition)
elif isinstance(e, SIPCoreError):
error = str(e)
else:
error = 'media stream failed: %s' % e.data.reason
self.state = 'terminated'
NotificationCenter().post_notification('JingleSessionDidFail', sender=self, data=NotificationData(originator='local', reason=error))
self._channel.send_exception(proc.ProcExit)
else:
self._timer = reactor.callLater(settings.sip.invite_timeout, self.end)
def _OH_RejectOperation(self, operation):
if self.state != 'incoming':
return
reason = jingle.Reason(jingle.ReasonType(operation.reason))
stanza = self._protocol.sessionTerminate(self._local_jid, self._remote_jid, self._id, reason)
self._send_stanza(stanza)
self.state = 'terminated'
self._channel.send_exception(proc.ProcExit)
def _OH_EndOperation(self, operation):
if self.state not in ('connecting', 'connected'):
return
if self._timer is not None and self._timer.active():
self._timer.cancel()
self._timer = None
prev_state = self.state
self.state = 'terminating'
notification_center = NotificationCenter()
notification_center.post_notification('JingleSessionWillEnd', self)
streams = (self.streams or []) + (self.proposed_streams or [])
for stream in streams[:]:
try:
notification_center.remove_observer(self, sender=stream)
except KeyError:
streams.remove(stream)
else:
stream.deactivate()
if prev_state == 'connected':
reason = jingle.Reason(jingle.ReasonType('success'))
else:
reason = jingle.Reason(jingle.ReasonType('cancel'))
stanza = self._protocol.sessionTerminate(self._local_jid, self._remote_jid, self._id, reason)
self._send_stanza(stanza)
self.state = 'terminated'
if prev_state == 'connected':
self.end_time = datetime.now()
notification_center.post_notification('JingleSessionDidEnd', self, NotificationData(originator='local'))
else:
notification_center.post_notification('JingleSessionDidFail', self, NotificationData(originator='local', reason='cancel'))
for stream in streams:
stream.end()
self._channel.send_exception(proc.ProcExit)
def _OH_SendRingIndicationOperation(self, operation):
if self.state != 'incoming':
return
stanza = self._protocol.sessionInfo(self._local_jid, self._remote_jid, self._id, jingle.Info('ringing'))
self._send_stanza(stanza)
def _OH_HoldOperation(self, operation):
if self.state != 'connected':
return
if self.on_hold:
return
self.on_hold = True
for stream in self.streams:
stream.hold()
stanza = self._protocol.sessionInfo(self._local_jid, self._remote_jid, self._id, jingle.Info('hold'))
self._send_stanza(stanza)
NotificationCenter().post_notification('JingleSessionDidChangeHoldState', self, NotificationData(originator='local', on_hold=True, partial=False))
def _OH_UnholdOperation(self, operation):
if self.state != 'connected':
return
if not self.on_hold:
return
self.on_hold = False
for stream in self.streams:
stream.unhold()
stanza = self._protocol.sessionInfo(self._local_jid, self._remote_jid, self._id, jingle.Info('unhold'))
self._send_stanza(stanza)
NotificationCenter().post_notification('JingleSessionDidChangeHoldState', self, NotificationData(originator='local', on_hold=False, partial=False))
def _OH_SendConferenceInfoOperation(self, operation):
if self.state != 'connected':
return
if not self.local_focus:
return
tree = etree.parse(StringIO(operation.xml))
tree.getroot().attrib['sid'] = self._id # FIXME: non-standard, but Jitsi does it
data = etree.tostring(tree, xml_declaration=False) # Strip the XML heading
stanza = jingle.ConferenceInfoIq(sender=self._local_jid, recipient=self._remote_jid, payload=data)
stanza.timeout = self.jingle_stanza_timeout
self._protocol.request(stanza)
def _OH_ProcessRemoteOperation(self, operation):
notification = operation.notification
stanza = notification.data.stanza
if notification.name == 'XMPPGotJingleSessionTerminate':
if self.state not in ('incoming', 'connecting', 'connected_pending_accept', 'connected'):
return
if self._timer is not None and self._timer.active():
self._timer.cancel()
self._timer = None
# Session ended remotely
prev_state = self.state
self.state = 'terminated'
if prev_state == 'incoming':
reason = stanza.jingle.reason.value if stanza.jingle.reason else 'cancel'
notification.center.post_notification('JingleSessionDidFail', self, NotificationData(originator='remote', reason=reason))
else:
notification.center.post_notification('JingleSessionWillEnd', self, NotificationData(originator='remote'))
streams = self.proposed_streams if prev_state == 'connecting' else self.streams
for stream in streams:
notification.center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self.end_time = datetime.now()
notification.center.post_notification('JingleSessionDidEnd', self, NotificationData(originator='remote'))
self._channel.send_exception(proc.ProcExit)
elif notification.name == 'XMPPGotJingleSessionInfo':
info = stanza.jingle.info
if not info:
return
if info == 'ringing':
if self.state not in ('connecting', 'connected_pending_accept'):
return
notification.center.post_notification('JingleSessionGotRingIndication', self)
elif info in ('hold', 'unhold'):
if self.state != 'connected':
return
notification.center.post_notification('JingleSessionDidChangeHoldState', self, NotificationData(originator='remote', on_hold=info=='hold', partial=False))
elif notification.name == 'XMPPGotJingleDescriptionInfo':
if self.state != 'connecting':
return
# Add candidates acquired on transport-info stanzas
for s in self._pending_transport_info_stanzas:
for c in s.jingle.content:
content = next(content for content in stanza.jingle.content if content.name == c.name)
content.transport.candidates.extend(c.transport.candidates)
if isinstance(content.transport, jingle.IceUdpTransport):
if not content.transport.ufrag and c.transport.ufrag:
content.transport.ufrag = c.transport.ufrag
if not content.transport.password and c.transport.password:
content.transport.password = c.transport.password
remote_sdp = jingle_to_sdp(stanza.jingle)
try:
self._sdp_negotiator.set_remote_answer(remote_sdp)
self._sdp_negotiator.negotiate()
except SIPCoreError:
# The description-info stanza may have been just a parameter change, not a full 'SDP'
return
if self._timer is not None and self._timer.active():
self._timer.cancel()
self._timer = None
del self._pending_transport_info_stanzas[:]
# Get active SDPs (negotiator may make changes)
local_sdp = self._sdp_negotiator.active_local
remote_sdp = self._sdp_negotiator.active_remote
notification.center.post_notification('JingleSessionWillStart', sender=self)
stream_map = dict((stream.index, stream) for stream in self.proposed_streams)
for index, local_media in enumerate(local_sdp.media):
remote_media = remote_sdp.media[index]
stream = stream_map[index]
if remote_media.port:
stream.start(local_sdp, remote_sdp, index)
else:
notification.center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
removed_streams = [stream for stream in self.proposed_streams if stream.index >= len(local_sdp.media)]
for stream in removed_streams:
notification.center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
try:
with api.timeout(self.media_stream_timeout):
wait_count = len(self.proposed_streams)
while wait_count > 0:
notification = operation.channel.wait()
if notification.name == 'MediaStreamDidStart':
wait_count -= 1
except (MediaStreamDidFailError, api.TimeoutError), e:
for stream in self.proposed_streams:
notification.center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
if isinstance(e, api.TimeoutError):
error = 'media stream timed out while starting'
else:
error = 'media stream failed: %s' % e.data.reason
self._fail(originator='local', reason='failed-application', description=error)
else:
self.state = 'connected_pending_accept'
self.streams = self.proposed_streams
self.proposed_streams = None
self.start_time = datetime.now()
# Hold the streams to prevent real RTP from flowing
for stream in self.streams:
stream.hold()
elif notification.name == 'XMPPGotJingleSessionAccept':
if self.state not in ('connecting', 'connected_pending_accept'):
return
if self._timer is not None and self._timer.active():
self._timer.cancel()
self._timer = None
if self.state == 'connected_pending_accept':
# We already negotiated ICE and media is 'flowing' (not really because streams are on hold)
# unhold the streams and pretend the session just started
for stream in self.streams:
stream.unhold()
self.state = 'connected'
notification.center.post_notification('JingleSessionDidStart', self, NotificationData(streams=self.streams))
return
# Add candidates acquired on transport-info stanzas
for s in self._pending_transport_info_stanzas:
for c in s.jingle.content:
content = next(content for content in stanza.jingle.content if content.name == c.name)
content.transport.candidates.extend(c.transport.candidates)
if isinstance(content.transport, jingle.IceUdpTransport):
if not content.transport.ufrag and c.transport.ufrag:
content.transport.ufrag = c.transport.ufrag
if not content.transport.password and c.transport.password:
content.transport.password = c.transport.password
del self._pending_transport_info_stanzas[:]
remote_sdp = jingle_to_sdp(stanza.jingle)
try:
self._sdp_negotiator.set_remote_answer(remote_sdp)
self._sdp_negotiator.negotiate()
except SIPCoreError, e:
for stream in self.proposed_streams:
notification.center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self._fail(originator='remote', reason='incompatible-parameters', description=str(e))
return
# Get active SDPs (negotiator may make changes)
local_sdp = self._sdp_negotiator.active_local
remote_sdp = self._sdp_negotiator.active_remote
notification.center.post_notification('JingleSessionWillStart', sender=self)
stream_map = dict((stream.index, stream) for stream in self.proposed_streams)
for index, local_media in enumerate(local_sdp.media):
remote_media = remote_sdp.media[index]
stream = stream_map[index]
if remote_media.port:
stream.start(local_sdp, remote_sdp, index)
else:
notification.center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
removed_streams = [stream for stream in self.proposed_streams if stream.index >= len(local_sdp.media)]
for stream in removed_streams:
notification.center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
try:
with api.timeout(self.media_stream_timeout):
wait_count = len(self.proposed_streams)
while wait_count > 0:
notification = operation.channel.wait()
if notification.name == 'MediaStreamDidStart':
wait_count -= 1
except (MediaStreamDidFailError, api.TimeoutError), e:
for stream in self.proposed_streams:
notification.center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
if isinstance(e, api.TimeoutError):
error = 'media stream timed out while starting'
else:
error = 'media stream failed: %s' % e.data.reason
self._fail(originator='local', reason='failed-application', description=error)
else:
self.state = 'connected'
self.streams = self.proposed_streams
self.proposed_streams = None
self.start_time = datetime.now()
notification.center.post_notification('JingleSessionDidStart', self, NotificationData(streams=self.streams))
elif notification.name == 'XMPPGotJingleTransportInfo':
if self.state != 'connecting':
# ICE trickling not supported yet, so only accept candidates before accept
return
self._pending_transport_info_stanzas.append(stanza)
class JingleSessionManager(object):
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
self.sessions = {}
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='JingleSessionNewIncoming')
notification_center.add_observer(self, name='JingleSessionNewOutgoing')
notification_center.add_observer(self, name='JingleSessionDidFail')
notification_center.add_observer(self, name='JingleSessionDidEnd')
def stop(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self, name='JingleSessionNewIncoming')
notification_center.remove_observer(self, name='JingleSessionNewOutgoing')
notification_center.remove_observer(self, name='JingleSessionDidFail')
notification_center.remove_observer(self, name='JingleSessionDidEnd')
def handle_notification(self, notification):
if notification.name in ('JingleSessionNewIncoming', 'JingleSessionNewOutgoing'):
session = notification.sender
self.sessions[session.id] = session
elif notification.name in ('JingleSessionDidFail', 'JingleSessionDidEnd'):
session = notification.sender
del self.sessions[session.id]
diff --git a/sylk/applications/xmppgateway/xmpp/jingle/streams/__init__.py b/sylk/applications/xmppgateway/xmpp/jingle/streams/__init__.py
index b88723f..e929aaf 100644
--- a/sylk/applications/xmppgateway/xmpp/jingle/streams/__init__.py
+++ b/sylk/applications/xmppgateway/xmpp/jingle/streams/__init__.py
@@ -1,120 +1,118 @@
-# Copyright (C) 2009-2011 AG Projects. See LICENSE for details.
-#
"""
This module automatically registers media streams to a stream registry
allowing for a plug and play mechanism of various types of media
negoticated in a SIP session that can be added to this library by using
a generic API.
For actual usage see rtp.py and msrp.py that implement media streams
based on their respective RTP and MSRP protocols.
"""
from operator import attrgetter
from application.python.types import Singleton
from zope.interface import Interface, Attribute
class StreamError(Exception): pass
class InvalidStreamError(StreamError): pass
class UnknownStreamError(StreamError): pass
# The MediaStream interface
#
class IMediaStream(Interface):
type = Attribute("A string identifying the stream type (ex: audio, video, ...)")
priority = Attribute("An integer value indicating the stream priority relative to the other streams types (higher numbers have higher priority).")
session = Attribute("Session object to which this stream is attached")
hold_supported = Attribute("True if the stream supports hold")
on_hold_by_local = Attribute("True if the stream is on hold by the local party")
on_hold_by_remote = Attribute("True if the stream is on hold by the remote")
on_hold = Attribute("True if either on_hold_by_local or on_hold_by_remote is true")
# this should be a classmethod, but zopeinterface complains if we decorate it with @classmethod -Dan
def new_from_sdp(cls, session, remote_sdp, stream_index):
pass
def get_local_media(self, for_offer):
pass
def initialize(self, session, direction):
pass
def start(self, local_sdp, remote_sdp, stream_index):
pass
def deactivate(self):
pass
def end(self):
pass
def validate_update(self, remote_sdp, stream_index):
pass
def update(self, local_sdp, remote_sdp, stream_index):
pass
def hold(self):
pass
def unhold(self):
pass
def reset(self, stream_index):
pass
# The MediaStream registry
#
class StreamDescriptor(object):
def __init__(self, type):
self.type = type
def __get__(self, obj, objtype):
return self if obj is None else obj.get(self.type)
def __set__(self, obj, value):
raise AttributeError('cannot set attribute')
def __delete__(self, obj):
raise AttributeError('cannot delete attribute')
class MediaStreamRegistry(object):
__metaclass__ = Singleton
def __init__(self):
self.__types__ = []
def __iter__(self):
return iter(self.__types__)
def add(self, cls):
if cls.priority is not None and cls not in self.__types__:
self.__types__.append(cls)
self.__types__.sort(key=attrgetter('priority'), reverse=True)
setattr(self.__class__, cls.type.title().translate(None, ' -_') + 'Stream', StreamDescriptor(cls.type))
def get(self, type):
try:
return next(cls for cls in self.__types__ if cls.type == type)
except StopIteration:
raise UnknownStreamError("unknown stream type: %s" % type)
class MediaStreamRegistrar(type):
"""Metaclass for adding a MediaStream to the media stream's class registry"""
def __init__(cls, name, bases, dic):
super(MediaStreamRegistrar, cls).__init__(name, bases, dic)
MediaStreamRegistry().add(cls)
# Import the streams defined in submodules
#
from sylk.applications.xmppgateway.xmpp.jingle.streams import rtp
from sylk.applications.xmppgateway.xmpp.jingle.streams.rtp import *
__all__ = ['StreamError', 'InvalidStreamError', 'UnknownStreamError', 'IMediaStream', 'MediaStreamRegistry', 'MediaStreamRegistrar'] + rtp.__all__
diff --git a/sylk/applications/xmppgateway/xmpp/jingle/streams/rtp.py b/sylk/applications/xmppgateway/xmpp/jingle/streams/rtp.py
index 3a6eb30..9d117e3 100644
--- a/sylk/applications/xmppgateway/xmpp/jingle/streams/rtp.py
+++ b/sylk/applications/xmppgateway/xmpp/jingle/streams/rtp.py
@@ -1,443 +1,441 @@
-# Copyright (C) 2009-2011 AG Projects. See LICENSE for details.
-#
"""
Handling of RTP media streams according to RFC3550, RFC3605, RFC3581,
RFC2833 and RFC3711, RFC3489 and draft-ietf-mmusic-ice-19.
"""
__all__ = ['AudioStream']
from threading import RLock
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from zope.interface import implements
from sipsimple.audio import AudioBridge, AudioDevice, IAudioPort
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import AudioTransport, PJSIPError, RTPTransport, SIPCoreError
from sipsimple.streams.rtp import RTPStreamEncryption
from sylk.applications.xmppgateway.xmpp.jingle.streams import IMediaStream, InvalidStreamError, MediaStreamRegistrar, UnknownStreamError
class AudioStream(object):
__metaclass__ = MediaStreamRegistrar
implements(IMediaStream, IAudioPort, IObserver)
type = 'audio'
priority = 1
hold_supported = True
def __init__(self):
from sipsimple.application import SIPApplication
self.mixer = SIPApplication.voice_audio_mixer
self.bridge = AudioBridge(self.mixer)
self.device = AudioDevice(self.mixer)
self.notification_center = NotificationCenter()
self.on_hold_by_local = False
self.on_hold_by_remote = False
self.direction = None
self.state = "NULL"
self._transport = None
self._hold_request = None
self._ice_state = "NULL"
self._lock = RLock()
self._rtp_transport = None
self.session = None
self.encryption = RTPStreamEncryption(self)
self._srtp_encryption = None
self._try_ice = False
self._initialized = False
self._done = False
self._failure_reason = None
self.bridge.add(self.device)
# Audio properties
#
@property
def codec(self):
return self._transport.codec if self._transport else None
@property
def consumer_slot(self):
return self._transport.slot if self._transport else None
@property
def producer_slot(self):
return self._transport.slot if self._transport and not self.muted else None
@property
def sample_rate(self):
return self._transport.sample_rate if self._transport else None
@property
def statistics(self):
return self._transport.statistics if self._transport else None
def _get_muted(self):
return self.__dict__.get('muted', False)
def _set_muted(self, value):
if not isinstance(value, bool):
raise ValueError("illegal value for muted property: %r" % (value,))
if value == self.muted:
return
old_producer_slot = self.producer_slot
self.__dict__['muted'] = value
notification_center = NotificationCenter()
data = NotificationData(consumer_slot_changed=False, producer_slot_changed=True, old_producer_slot=old_producer_slot, new_producer_slot=self.producer_slot)
notification_center.post_notification('AudioPortDidChangeSlots', sender=self, data=data)
muted = property(_get_muted, _set_muted)
del _get_muted, _set_muted
# RTP properties
#
@property
def local_rtp_address(self):
return self._rtp_transport.local_rtp_address if self._rtp_transport else None
@property
def local_rtp_port(self):
return self._rtp_transport.local_rtp_port if self._rtp_transport else None
@property
def remote_rtp_address(self):
if self._ice_state == "IN_USE":
return self._rtp_transport.remote_rtp_address_received if self._rtp_transport else None
else:
return self._rtp_transport.remote_rtp_address_sdp if self._rtp_transport else None
@property
def remote_rtp_port(self):
if self._ice_state == "IN_USE":
return self._rtp_transport.remote_rtp_port_received if self._rtp_transport else None
else:
return self._rtp_transport.remote_rtp_port_sdp if self._rtp_transport else None
@property
def local_rtp_candidate_type(self):
return self._rtp_transport.local_rtp_candidate_type if self._rtp_transport else None
@property
def remote_rtp_candidate_type(self):
return self._rtp_transport.remote_rtp_candidate_type if self._rtp_transport else None
@property
def ice_active(self):
return self._ice_state == "IN_USE"
# Generic properties
#
@property
def on_hold(self):
return self.on_hold_by_local or self.on_hold_by_remote
# Public methods
#
@classmethod
def new_from_sdp(cls, session, remote_sdp, stream_index):
# TODO: actually validate the SDP
settings = SIPSimpleSettings()
remote_stream = remote_sdp.media[stream_index]
if remote_stream.media != 'audio':
raise UnknownStreamError
if remote_stream.transport not in ('RTP/AVP', 'RTP/SAVP'):
raise InvalidStreamError("expected RTP/AVP or RTP/SAVP transport in audio stream, got %s" % remote_stream.transport)
local_encryption_policy = 'sdes_optional'
if local_encryption_policy == "sdes_mandatory" and not "crypto" in remote_stream.attributes:
raise InvalidStreamError("SRTP/SDES is locally mandatory but it's not remotely enabled")
if remote_stream.transport == 'RTP/SAVP' and "crypto" in remote_stream.attributes and local_encryption_policy not in ("opportunistic", "sdes_optional", "sdes_mandatory"):
raise InvalidStreamError("SRTP/SDES is remotely mandatory but it's not locally enabled")
supported_codecs = session.account.rtp.audio_codec_list or settings.rtp.audio_codec_list
if not any(codec for codec in remote_stream.codec_list if codec in supported_codecs):
raise InvalidStreamError("no compatible codecs found")
stream = cls()
stream._incoming_remote_sdp = remote_sdp
stream._incoming_stream_index = stream_index
if "zrtp-hash" in remote_stream.attributes:
stream._incoming_stream_encryption = 'zrtp'
elif "crypto" in remote_stream.attributes:
stream._incoming_stream_encryption = 'sdes_mandatory' if remote_stream.transport=='RTP/SAVP' else 'sdes_optional'
else:
stream._incoming_stream_encryption = None
return stream
def initialize(self, session, direction):
with self._lock:
if self.state != "NULL":
raise RuntimeError("AudioStream.initialize() may only be called in the NULL state")
self.state = "INITIALIZING"
self.session = session
local_encryption_policy = 'sdes_optional'
if hasattr(self, "_incoming_remote_sdp"):
# ICE attributes could come at the session level or at the media level
remote_stream = self._incoming_remote_sdp.media[self._incoming_stream_index]
self._try_ice = (remote_stream.has_ice_attributes or self._incoming_remote_sdp.has_ice_attributes) and remote_stream.has_ice_candidates
if self._incoming_stream_encryption is not None and local_encryption_policy == 'opportunistic':
self._srtp_encryption = self._incoming_stream_encryption
else:
self._srtp_encryption = 'zrtp' if local_encryption_policy == 'opportunistic' else local_encryption_policy
del self._incoming_stream_encryption
else:
self._try_ice = True
self._srtp_encryption = 'zrtp' if local_encryption_policy == 'opportunistic' else local_encryption_policy
self._init_rtp_transport()
def get_local_media(self, remote_sdp=None, index=0):
with self._lock:
if self.state not in ["INITIALIZED", "WAIT_ICE", "ESTABLISHED"]:
raise RuntimeError("AudioStream.get_local_media() may only be called in the INITIALIZED, WAIT_ICE or ESTABLISHED states")
if remote_sdp is None:
# offer
old_direction = self._transport.direction
if old_direction is None:
new_direction = "sendrecv"
elif "send" in old_direction:
new_direction = ("sendonly" if (self._hold_request == 'hold' or (self._hold_request is None and self.on_hold_by_local)) else "sendrecv")
else:
new_direction = ("inactive" if (self._hold_request == 'hold' or (self._hold_request is None and self.on_hold_by_local)) else "recvonly")
else:
new_direction = None
return self._transport.get_local_media(remote_sdp, index, new_direction)
def start(self, local_sdp, remote_sdp, stream_index):
with self._lock:
if self.state != "INITIALIZED":
raise RuntimeError("AudioStream.start() may only be called in the INITIALIZED state")
settings = SIPSimpleSettings()
self._transport.start(local_sdp, remote_sdp, stream_index, no_media_timeout=settings.rtp.timeout,
media_check_interval=settings.rtp.timeout)
self._check_hold(self._transport.direction, True)
if self._try_ice:
self.state = 'WAIT_ICE'
else:
self.state = 'ESTABLISHED'
self.notification_center.post_notification('MediaStreamDidStart', sender=self)
def validate_update(self, remote_sdp, stream_index):
with self._lock:
# TODO: implement
return True
def update(self, local_sdp, remote_sdp, stream_index):
with self._lock:
connection = remote_sdp.media[stream_index].connection or remote_sdp.connection
if not self._rtp_transport.ice_active and (connection.address != self._rtp_transport.remote_rtp_address_sdp or self._rtp_transport.remote_rtp_port_sdp != remote_sdp.media[stream_index].port):
settings = SIPSimpleSettings()
old_consumer_slot = self.consumer_slot
old_producer_slot = self.producer_slot
self.notification_center.remove_observer(self, sender=self._transport)
self._transport.stop()
try:
self._transport = AudioTransport(self.mixer, self._rtp_transport, remote_sdp, stream_index, codecs=list(self.session.account.rtp.audio_codec_list or settings.rtp.audio_codec_list))
except SIPCoreError, e:
self.state = "ENDED"
self._failure_reason = e.args[0]
self.notification_center.post_notification('MediaStreamDidFail', sender=self, data=NotificationData(reason=self._failure_reason))
return
self.notification_center.add_observer(self, sender=self._transport)
self._transport.start(local_sdp, remote_sdp, stream_index, no_media_timeout=settings.rtp.timeout, media_check_interval=settings.rtp.timeout)
self.notification_center.post_notification('AudioPortDidChangeSlots', sender=self, data=NotificationData(consumer_slot_changed=True, producer_slot_changed=True,
old_consumer_slot=old_consumer_slot, new_consumer_slot=self.consumer_slot,
old_producer_slot=old_producer_slot, new_producer_slot=self.producer_slot))
if connection.address == '0.0.0.0' and remote_sdp.media[stream_index].direction == 'sendrecv':
self._transport.update_direction('recvonly')
self._check_hold(self._transport.direction, False)
self.notification_center.post_notification('RTPStreamDidChangeRTPParameters', sender=self)
else:
new_direction = local_sdp.media[stream_index].direction
self._transport.update_direction(new_direction)
self._check_hold(new_direction, False)
self._hold_request = None
def hold(self):
with self._lock:
if self.on_hold_by_local or self._hold_request == 'hold':
return
if self.state == "ESTABLISHED" and self.direction != "inactive":
self.bridge.remove(self)
self._hold_request = 'hold'
def unhold(self):
with self._lock:
if (not self.on_hold_by_local and self._hold_request != 'hold') or self._hold_request == 'unhold':
return
if self.state == "ESTABLISHED" and self._hold_request == 'hold':
self.bridge.add(self)
self._hold_request = None if self._hold_request == 'hold' else 'unhold'
def deactivate(self):
with self._lock:
self.bridge.stop()
def end(self):
with self._lock:
if not self._initialized or self._done:
return
self._done = True
self.notification_center.post_notification('MediaStreamWillEnd', sender=self)
if self._transport is not None:
self._transport.stop()
self.notification_center.remove_observer(self, sender=self._transport)
self._transport = None
self.notification_center.remove_observer(self, sender=self._rtp_transport)
self._rtp_transport = None
self.state = "ENDED"
self.notification_center.post_notification('MediaStreamDidEnd', sender=self, data=NotificationData(error=self._failure_reason))
self.session = None
def reset(self, stream_index):
with self._lock:
if self.direction == "inactive" and not self.on_hold_by_local:
new_direction = "sendrecv"
self._transport.update_direction(new_direction)
self._check_hold(new_direction, False)
# TODO: do a full reset, re-creating the AudioTransport, so that a new offer
# would contain all codecs and ICE would be renegotiated -Saul
def send_dtmf(self, digit):
with self._lock:
if self.state != "ESTABLISHED":
raise RuntimeError("AudioStream.send_dtmf() cannot be used in %s state" % self.state)
try:
self._transport.send_dtmf(digit)
except PJSIPError, e:
if not e.args[0].endswith("(PJ_ETOOMANY)"):
raise
# Notification handling
#
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_RTPTransportDidFail(self, notification):
with self._lock:
self.notification_center.remove_observer(self, sender=notification.sender)
if self.state == "ENDED":
return
self._try_next_rtp_transport(notification.data.reason)
def _NH_RTPTransportDidInitialize(self, notification):
settings = SIPSimpleSettings()
rtp_transport = notification.sender
with self._lock:
if self.state == "ENDED":
return
del self._rtp_args
del self._stun_servers
try:
if hasattr(self, "_incoming_remote_sdp"):
try:
audio_transport = AudioTransport(self.mixer, rtp_transport, self._incoming_remote_sdp, self._incoming_stream_index,
codecs=list(self.session.account.rtp.audio_codec_list or settings.rtp.audio_codec_list))
finally:
del self._incoming_remote_sdp
del self._incoming_stream_index
else:
audio_transport = AudioTransport(self.mixer, rtp_transport, codecs=list(self.session.account.rtp.audio_codec_list or settings.rtp.audio_codec_list))
except SIPCoreError, e:
self.state = "ENDED"
self.notification_center.post_notification('MediaStreamDidNotInitialize', sender=self, data=NotificationData(reason=e.args[0]))
return
self._rtp_transport = rtp_transport
self._transport = audio_transport
self.notification_center.add_observer(self, sender=audio_transport)
self._initialized = True
self.state = "INITIALIZED"
self.notification_center.post_notification('MediaStreamDidInitialize', sender=self)
def _NH_RTPAudioStreamGotDTMF(self, notification):
self.notification_center.post_notification('AudioStreamGotDTMF', sender=self, data=NotificationData(digit=notification.data.digit))
def _NH_RTPAudioTransportDidTimeout(self, notification):
self.notification_center.post_notification('RTPStreamDidTimeout', sender=self)
def _NH_RTPTransportICENegotiationStateDidChange(self, notification):
with self._lock:
if self._ice_state != "NULL" or self.state not in ("INITIALIZING", "INITIALIZED", "WAIT_ICE"):
return
self.notification_center.post_notification('RTPStreamICENegotiationStateDidChange', sender=self, data=notification.data)
def _NH_RTPTransportICENegotiationDidSucceed(self, notification):
with self._lock:
if self.state != "WAIT_ICE":
return
self._ice_state = "IN_USE"
self.state = 'ESTABLISHED'
self.notification_center.post_notification('RTPStreamICENegotiationDidSucceed', sender=self, data=notification.data)
self.notification_center.post_notification('MediaStreamDidStart', sender=self)
def _NH_RTPTransportICENegotiationDidFail(self, notification):
with self._lock:
if self.state != "WAIT_ICE":
return
self._ice_state = "FAILED"
self.state = 'ESTABLISHED'
self.notification_center.post_notification('RTPStreamICENegotiationDidFail', sender=self, data=notification.data)
self.notification_center.post_notification('MediaStreamDidStart', sender=self)
# Private methods
#
def _init_rtp_transport(self, stun_servers=None):
self._rtp_args = dict()
self._rtp_args["encryption"] = self._srtp_encryption
self._rtp_args["use_ice"] = self._try_ice
self._stun_servers = [(None, None)]
if stun_servers:
self._stun_servers.extend(reversed(stun_servers))
self._try_next_rtp_transport()
def _try_next_rtp_transport(self, failure_reason=None):
if self._stun_servers:
stun_address, stun_port = self._stun_servers.pop()
observer_added = False
try:
rtp_transport = RTPTransport(ice_stun_address=stun_address, ice_stun_port=stun_port, **self._rtp_args)
self.notification_center.add_observer(self, sender=rtp_transport)
observer_added = True
rtp_transport.set_INIT()
except SIPCoreError, e:
if observer_added:
self.notification_center.remove_observer(self, sender=rtp_transport)
self._try_next_rtp_transport(e.args[0])
else:
self.state = "ENDED"
self.notification_center.post_notification('MediaStreamDidNotInitialize', sender=self, data=NotificationData(reason=failure_reason))
def _check_hold(self, direction, is_initial):
was_on_hold_by_local = self.on_hold_by_local
was_on_hold_by_remote = self.on_hold_by_remote
was_inactive = self.direction == "inactive"
self.direction = direction
inactive = self.direction == "inactive"
self.on_hold_by_local = was_on_hold_by_local if inactive else direction == "sendonly"
self.on_hold_by_remote = "send" not in direction
if (is_initial or was_on_hold_by_local or was_inactive) and not inactive and not self.on_hold_by_local and self._hold_request != 'hold':
self.bridge.add(self)
if not was_on_hold_by_local and self.on_hold_by_local:
self.notification_center.post_notification('RTPStreamDidChangeHoldState', sender=self, data=NotificationData(originator="local", on_hold=True))
if was_on_hold_by_local and not self.on_hold_by_local:
self.notification_center.post_notification('RTPStreamDidChangeHoldState', sender=self, data=NotificationData(originator="local", on_hold=False))
if not was_on_hold_by_remote and self.on_hold_by_remote:
self.notification_center.post_notification('RTPStreamDidChangeHoldState', sender=self, data=NotificationData(originator="remote", on_hold=True))
if was_on_hold_by_remote and not self.on_hold_by_remote:
self.notification_center.post_notification('RTPStreamDidChangeHoldState', sender=self, data=NotificationData(originator="remote", on_hold=False))
diff --git a/sylk/applications/xmppgateway/xmpp/jingle/util.py b/sylk/applications/xmppgateway/xmpp/jingle/util.py
index fe8d00f..7dd946b 100644
--- a/sylk/applications/xmppgateway/xmpp/jingle/util.py
+++ b/sylk/applications/xmppgateway/xmpp/jingle/util.py
@@ -1,155 +1,153 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
import re
from collections import defaultdict
from itertools import count
from sipsimple.core import SDPSession, SDPMediaStream, SDPAttribute, SDPConnection
from sylk.applications.xmppgateway.xmpp.stanzas import jingle
__all__ = ['jingle_to_sdp', 'sdp_to_jingle']
# IPv4 only for now, I'm sorry
ipv4_re = re.compile("^\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}$")
def content_to_sdpstream(content):
if content.description is None or content.transport is None:
raise ValueError
media_stream = SDPMediaStream(str(content.description.media), 0, 'RTP/AVP')
formats = []
attributes = []
for item in content.description.payloads:
formats.append(item.id)
attributes.append(SDPAttribute('rtpmap', '%d %s/%d' % (item.id, str(item.name), item.clockrate)))
if item.maxptime:
attributes.append(SDPAttribute('maxptime', str(item.maxptime)))
if item.ptime:
attributes.append(SDPAttribute('ptime', str(item.ptime)))
if item.parameters:
parameters_str = ';'.join(('%s=%s' % (p.name, p.value) for p in item.parameters))
attributes.append(SDPAttribute('fmtp', '%d %s' % (item.id, str(parameters_str))))
media_stream.formats = map(str, formats)
media_stream.attributes = attributes # set attributes so that _codec_list is generated
if content.description.encryption:
if content.description.encryption.required:
media_stream.transport = 'RTP/SAVP'
for crypto in content.description.encryption.cryptos:
crypto_str = '%s %s %s' % (crypto.tag, crypto.crypto_suite, crypto.key_params)
if crypto.session_params:
crypto_str += ' %s' % crypto.session_params
media_stream.attributes.append(SDPAttribute('crypto', str(crypto_str)))
if isinstance(content.transport, jingle.IceUdpTransport):
if content.transport.ufrag:
media_stream.attributes.append(SDPAttribute('ice-ufrag', str(content.transport.ufrag)))
if content.transport.password:
media_stream.attributes.append(SDPAttribute('ice-pwd', str(content.transport.password)))
for candidate in content.transport.candidates:
if not ipv4_re.match(candidate.ip):
continue
candidate_str = '%s %d %s %d %s %d typ %s' % (candidate.foundation, candidate.component, candidate.protocol.upper(), candidate.priority, candidate.ip, candidate.port, candidate.typ)
if candidate.related_addr and candidate.related_port:
candidate_str += ' raddr %s rport %d' % (candidate.related_addr, candidate.related_port)
media_stream.attributes.append(SDPAttribute('candidate', str(candidate_str)))
if content.transport.remote_candidate:
remote_candidate = content.transport.remote_candidate
remote_candidates_str = '%d %s %d' % (remote_candidate.component, remote_candidate.ip, remote_candidate.port)
media_stream.attributes.append(SDPAttribute('remote-candidates', str(remote_candidates_str)))
elif isinstance(content.transport, jingle.RawUdpTransport):
# Nothing to do here
pass
else:
raise ValueError
# Set the proper connection information, pick the first RTP candidate and use that
try:
candidate = next(c for c in content.transport.candidates if c.component == 1 and ipv4_re.match(c.ip))
except StopIteration:
raise ValueError
media_stream.connection = SDPConnection(str(candidate.ip))
media_stream.port = candidate.port
return media_stream
def jingle_to_sdp(payload):
sdp = SDPSession('127.0.0.1')
for c in payload.content:
try:
media_stream = content_to_sdpstream(c)
except ValueError:
continue
sdp.media.append(media_stream)
return sdp
ice_candidate_re = re.compile(r"""^(?P[a-zA-Z0-9+/]+) (?P\d+) (?P[a-zA-Z]+) (?P\d+) (?P[0-9a-fA-F.:]+) (?P\d+) typ (?P[a-zA-Z]+)(?: raddr (?P[0-9a-fA-F.:]+) rport (?P\d+))?$""", re.MULTILINE)
crypto_re = re.compile(r"""^(?P\d+) (?P[a-zA-Z0-9\_]+) (?P[a-zA-Z0-9\:\+]+)(?: (?P[a-zA-Z0-9\:\+]+))?$""", re.MULTILINE)
def sdpstream_to_content(sdp, index):
media_stream = sdp.media[index]
content = jingle.Content('initiator', media_stream.media)
content.description = jingle.RTPDescription(media=media_stream.media)
try:
ptime = next(attr.value for attr in media_stream.attributes if attr.name=='ptime')
except StopIteration:
ptime = None
try:
maxptime = next(attr.value for attr in media_stream.attributes if attr.name=='maxptime')
except StopIteration:
maxptime = None
rtp_mappings = media_stream.rtp_mappings.copy()
MediaCodec = rtp_mappings[0].__class__
rtpmap_lines = '\n'.join(attr.value for attr in media_stream.attributes if attr.name=='rtpmap')
rtpmap_codecs = dict([(int(type), MediaCodec(name, rate)) for type, name, rate in media_stream.rtpmap_re.findall(rtpmap_lines)])
rtp_mappings.update(rtpmap_codecs)
for item in media_stream.formats:
codec = rtp_mappings.get(int(item), None)
if codec is not None:
pt = jingle.PayloadType(int(item), codec.name, codec.rate, 1, ptime=ptime, maxptime=maxptime)
for attr in (attr for attr in media_stream.attributes if attr.name=='fmtp' and attr.value.startswith(item)):
value = attr.value.split(' ', 1)[1]
for v in value.split(';'):
fmtp_name, sep, fmtp_value = v.partition('=')
pt.parameters.append(jingle.Parameter(fmtp_name, fmtp_value))
content.description.payloads.append(pt)
content.description.encryption = jingle.Encryption(required=media_stream.transport=='RTP/SAVP')
crypto_lines = '\n'.join(attr.value for attr in media_stream.attributes if attr.name=='crypto')
for tag, suite, key_params, session_params in crypto_re.findall(crypto_lines):
content.description.encryption.cryptos.append(jingle.Crypto(suite, key_params, tag, session_params))
if media_stream.has_ice_candidates:
foundation_counter = count(1)
foundation_map = defaultdict(foundation_counter.next)
id_counter = count(100)
if not media_stream.has_ice_attributes and not sdp.has_ice_attributes:
raise ValueError
ufrag_attr = next(attr for attr in media_stream.attributes+sdp.attributes if attr.name=='ice-ufrag')
pwd_attr = next(attr for attr in media_stream.attributes+sdp.attributes if attr.name=='ice-pwd')
content.transport = jingle.IceUdpTransport(ufrag=ufrag_attr.value, pwd=pwd_attr.value)
candidate_lines = '\n'.join(attr.value for attr in media_stream.attributes if attr.name=='candidate')
for foundation, component, protocol, priority, ip, port, type, raddr, rport in ice_candidate_re.findall(candidate_lines):
candidate = jingle.ICECandidate(component, foundation_map[foundation], 0, next(id_counter), ip, 0, port, priority, protocol.lower(), type, raddr or None, rport or None)
content.transport.candidates.append(candidate)
# TODO: translate remote-candidate
else:
content.transport = jingle.RawUdpTransport()
connection = media_stream.connection or sdp.connection
if not connection:
raise ValueError
content.transport.candidates.append(jingle.UDPCandidate(1, 0, 100, connection.address, media_stream.port, 'UDP'))
# TODO: component for RTCP
return content
def sdp_to_jingle(sdp):
payload = jingle.Jingle(None, None)
# action and sid will be filled up by the session
for index, media_stream in enumerate(sdp.media):
try:
content = sdpstream_to_content(sdp, index)
except ValueError:
continue
payload.content.append(content)
return payload
diff --git a/sylk/applications/xmppgateway/xmpp/logger.py b/sylk/applications/xmppgateway/xmpp/logger.py
index ce26dda..6e2f4d9 100644
--- a/sylk/applications/xmppgateway/xmpp/logger.py
+++ b/sylk/applications/xmppgateway/xmpp/logger.py
@@ -1,99 +1,97 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
"""
Logging support for XMPP traffic.
"""
__all__ = ["Logger"]
import os
import sys
from application.system import makedirs
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.threading import run_in_thread
class Logger(object):
def __init__(self):
self.stopped = False
self._xmpptrace_filename = None
self._xmpptrace_file = None
self._xmpptrace_error = False
self._xmpptrace_start_time = None
self._xmpptrace_packet_count = 0
self._log_directory_error = False
def start(self):
# try to create the log directory
try:
self._init_log_directory()
self._init_log_file()
except Exception:
pass
self.stopped = False
def stop(self):
self.stopped = True
if self._xmpptrace_file is not None:
self._xmpptrace_file.close()
self._xmpptrace_file = None
def msg(self, direction, timestamp, packet):
if self._xmpptrace_start_time is None:
self._xmpptrace_start_time = timestamp
self._xmpptrace_packet_count += 1
buf = ["%s: Packet %d, +%s" % (direction, self._xmpptrace_packet_count, (timestamp - self._xmpptrace_start_time))]
buf.append(packet)
buf.append('--')
message = '\n'.join(buf)
self._process_log((message, timestamp))
@run_in_thread('log-io')
def _process_log(self, record):
if self.stopped:
return
message, timestamp = record
try:
self._init_log_file()
except Exception:
pass
else:
self._xmpptrace_file.write('%s [%s %d]: %s\n' % (timestamp, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._xmpptrace_file.flush()
def _init_log_directory(self):
settings = SIPSimpleSettings()
log_directory = settings.logs.directory.normalized
try:
makedirs(log_directory)
except Exception, e:
if not self._log_directory_error:
print "failed to create logs directory '%s': %s" % (log_directory, e)
self._log_directory_error = True
self._xmpptrace_error = True
raise
else:
self._log_directory_error = False
if self._xmpptrace_filename is None:
self._xmpptrace_filename = os.path.join(log_directory, 'xmpp_trace.log')
self._xmpptrace_error = False
def _init_log_file(self):
if self._xmpptrace_file is None:
self._init_log_directory()
filename = self._xmpptrace_filename
try:
self._xmpptrace_file = open(filename, 'a')
except Exception, e:
if not self._xmpptrace_error:
print "failed to create log file '%s': %s" % (filename, e)
self._xmpptrace_error = True
raise
else:
self._xmpptrace_error = False
diff --git a/sylk/applications/xmppgateway/xmpp/protocols.py b/sylk/applications/xmppgateway/xmpp/protocols.py
index ac1b6de..faf6949 100644
--- a/sylk/applications/xmppgateway/xmpp/protocols.py
+++ b/sylk/applications/xmppgateway/xmpp/protocols.py
@@ -1,383 +1,381 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
from application.notification import NotificationCenter, NotificationData
from twisted.internet import defer, reactor
from twisted.words.protocols.jabber.error import StanzaError
from twisted.words.protocols.jabber.jid import JID
from wokkel import disco, muc, ping, xmppim
from sylk.applications.xmppgateway.configuration import XMPPGatewayConfig
from sylk.applications.xmppgateway.datatypes import Identity, FrozenURI
from sylk.applications.xmppgateway.xmpp.stanzas import (RECEIPTS_NS, CHATSTATES_NS, MUC_USER_NS, ErrorStanza,
NormalMessage, MessageReceipt, ChatMessage, ChatComposingIndication,
AvailabilityPresence, SubscriptionPresence, ProbePresence,
MUCAvailabilityPresence, GroupChatMessage, IncomingInvitationMessage)
from sylk.applications.xmppgateway.xmpp.stanzas import jingle
__all__ = ['DiscoProtocol', 'JingleProtocol', 'MessageProtocol', 'MUCServerProtocol', 'MUCPresenceProtocol', 'PresenceProtocol']
class MessageProtocol(xmppim.MessageProtocol):
messageTypes = None, 'normal', 'chat', 'headline', 'groupchat', 'error'
def _onMessage(self, message):
if message.handled:
return
messageType = message.getAttribute("type")
if messageType not in self.messageTypes:
message["type"] = 'normal'
self.onMessage(message)
def onMessage(self, msg):
notification_center = NotificationCenter()
sender_uri = FrozenURI.parse('xmpp:'+msg['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+msg['to'])
recipient = Identity(recipient_uri)
msg_type = msg.getAttribute('type')
msg_id = msg.getAttribute('id', None)
is_empty = msg.body is None and msg.html is None
if msg_type == 'error':
error_type = msg.error['type']
conditions = [(child.name, child.defaultUri) for child in msg.error.elements()]
error_message = ErrorStanza('message', sender, recipient, error_type, conditions, id=msg_id)
notification_center.post_notification('XMPPGotErrorMessage', sender=self.parent, data=NotificationData(error_message=error_message))
return
if msg_type in (None, 'normal', 'chat') and not is_empty:
body = None
html_body = None
if msg.html is not None:
html_body = msg.html.toXml()
if msg.body is not None:
body = unicode(msg.body)
try:
elem = next(c for c in msg.elements() if c.uri == RECEIPTS_NS)
except StopIteration:
use_receipt = False
else:
use_receipt = elem.name == u'request'
if msg_type == 'chat':
message = ChatMessage(sender, recipient, body, html_body, id=msg_id, use_receipt=use_receipt)
notification_center.post_notification('XMPPGotChatMessage', sender=self.parent, data=NotificationData(message=message))
else:
message = NormalMessage(sender, recipient, body, html_body, id=msg_id, use_receipt=use_receipt)
notification_center.post_notification('XMPPGotNormalMessage', sender=self.parent, data=NotificationData(message=message))
return
# Check if it's a composing indication
if msg_type == 'chat' and is_empty:
for elem in msg.elements():
try:
elem = next(c for c in msg.elements() if c.uri == CHATSTATES_NS)
except StopIteration:
pass
else:
composing_indication = ChatComposingIndication(sender, recipient, elem.name, id=msg_id)
notification_center.post_notification('XMPPGotComposingIndication', sender=self.parent, data=NotificationData(composing_indication=composing_indication))
return
# Check if it's a receipt acknowledgement
if is_empty:
try:
elem = next(c for c in msg.elements() if c.uri == RECEIPTS_NS)
except StopIteration:
pass
else:
if elem.name == u'received' and msg_id is not None:
receipt = MessageReceipt(sender, recipient, msg_id)
notification_center.post_notification('XMPPGotReceipt', sender=self.parent, data=NotificationData(receipt=receipt))
class PresenceProtocol(xmppim.PresenceProtocol):
def availableReceived(self, stanza):
sender_uri = FrozenURI.parse('xmpp:'+stanza.element['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+stanza.element['to'])
recipient = Identity(recipient_uri)
id = stanza.element.getAttribute('id')
show = stanza.show
statuses = stanza.statuses
presence_stanza = AvailabilityPresence(sender, recipient, available=True, show=show, statuses=statuses, id=id)
NotificationCenter().post_notification('XMPPGotPresenceAvailability', sender=self.parent, data=NotificationData(presence_stanza=presence_stanza))
def unavailableReceived(self, stanza):
sender_uri = FrozenURI.parse('xmpp:'+stanza.element['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+stanza.element['to'])
recipient = Identity(recipient_uri)
id = stanza.element.getAttribute('id')
presence_stanza = AvailabilityPresence(sender, recipient, available=False, id=id)
NotificationCenter().post_notification('XMPPGotPresenceAvailability', sender=self.parent, data=NotificationData(presence_stanza=presence_stanza))
def _process_subscription_stanza(self, stanza):
sender_uri = FrozenURI.parse('xmpp:'+stanza.element['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+stanza.element['to'])
recipient = Identity(recipient_uri)
id = stanza.element.getAttribute('id')
type = stanza.element.getAttribute('type')
presence_stanza = SubscriptionPresence(sender, recipient, type, id=id)
NotificationCenter().post_notification('XMPPGotPresenceSubscriptionStatus', sender=self.parent, data=NotificationData(presence_stanza=presence_stanza))
def subscribedReceived(self, stanza):
self._process_subscription_stanza(stanza)
def unsubscribedReceived(self, stanza):
self._process_subscription_stanza(stanza)
def subscribeReceived(self, stanza):
self._process_subscription_stanza(stanza)
def unsubscribeReceived(self, stanza):
self._process_subscription_stanza(stanza)
def probeReceived(self, stanza):
sender_uri = FrozenURI.parse('xmpp:'+stanza.element['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+stanza.element['to'])
recipient = Identity(recipient_uri)
id = stanza.element.getAttribute('id')
presence_stanza = ProbePresence(sender, recipient, id=id)
NotificationCenter().post_notification('XMPPGotPresenceProbe', sender=self.parent, data=NotificationData(presence_stanza=presence_stanza))
class MUCServerProtocol(xmppim.BasePresenceProtocol):
messageTypes = None, 'normal', 'chat', 'groupchat'
presenceTypeParserMap = {'available': muc.UserPresence,
'unavailable': muc.UserPresence}
def connectionInitialized(self):
self.xmlstream.addObserver('/presence/x[@xmlns="%s"]' % muc.NS_MUC, self._onPresence)
self.xmlstream.addObserver('/message', self._onMessage)
def _onMessage(self, message):
if message.handled:
return
messageType = message.getAttribute("type")
if messageType == 'error':
return
if messageType not in self.messageTypes:
message['type'] = 'normal'
if messageType == 'groupchat':
self.onGroupChat(message)
else:
to_uri = FrozenURI.parse('xmpp:'+message['to'])
if to_uri.host in self.parent.domains:
# Check if it's an invitation
if message.x is not None and message.x.invite is not None and message.x.invite.uri == MUC_USER_NS:
self.onInvitation(message)
else:
# TODO: give error, private messages not supported
pass
def onGroupChat(self, msg):
sender_uri = FrozenURI.parse('xmpp:'+msg['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+msg['to'])
recipient = Identity(recipient_uri)
body = None
html_body = None
if msg.html is not None:
html_body = msg.html.toXml()
if msg.body is not None:
body = unicode(msg.body)
message = GroupChatMessage(sender, recipient, body, html_body, id=msg.getAttribute('id', None))
NotificationCenter().post_notification('XMPPMucGotGroupChat', sender=self.parent, data=NotificationData(message=message))
def onInvitation(self, msg):
sender_uri = FrozenURI.parse('xmpp:'+msg['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+msg['to'])
recipient = Identity(recipient_uri)
invited_user_uri = FrozenURI.parse('xmpp:'+msg.x.invite['to'])
invited_user = Identity(invited_user_uri)
if msg.x.invite.reason is not None and msg.x.invite.reason.uri == MUC_USER_NS:
reason = unicode(msg.x.invite.reason)
else:
reason = None
invitation = IncomingInvitationMessage(sender, recipient, invited_user=invited_user, reason=reason, id=msg.getAttribute('id', None))
NotificationCenter().post_notification('XMPPMucGotInvitation', sender=self.parent, data=NotificationData(invitation=invitation))
def availableReceived(self, stanza):
sender_uri = FrozenURI.parse('xmpp:'+stanza.element['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+stanza.element['to'])
recipient = Identity(recipient_uri)
id = stanza.element.getAttribute('id')
presence_stanza = MUCAvailabilityPresence(sender, recipient, available=True, id=id)
NotificationCenter().post_notification('XMPPMucGotPresenceAvailability', sender=self.parent, data=NotificationData(presence_stanza=presence_stanza))
def unavailableReceived(self, stanza):
sender_uri = FrozenURI.parse('xmpp:'+stanza.element['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+stanza.element['to'])
recipient = Identity(recipient_uri)
id = stanza.element.getAttribute('id')
presence_stanza = MUCAvailabilityPresence(sender, recipient, available=False, id=id)
NotificationCenter().post_notification('XMPPMucGotPresenceAvailability', sender=self.parent, data=NotificationData(presence_stanza=presence_stanza))
class DiscoProtocol(disco.DiscoHandler):
def info(self, requestor, target, nodeIdentifier):
"""
Gather data for a disco info request.
@param requestor: The entity that sent the request.
@type requestor: L{JID}
@param target: The entity the request was sent to.
@type target: L{JID}
@param nodeIdentifier: The optional node being queried, or C{''}.
@type nodeIdentifier: C{unicode}
@return: Deferred with the gathered results from sibling handlers.
@rtype: L{defer.Deferred}
"""
xmpp_manager = self.parent.manager
if target.host not in xmpp_manager.domains | xmpp_manager.muc_domains:
return defer.fail(StanzaError('service-unavailable'))
elements = []
elements.append(disco.DiscoFeature(disco.NS_DISCO_INFO))
elements.append(disco.DiscoFeature(disco.NS_DISCO_ITEMS))
elements.append(disco.DiscoFeature('http://sylkserver.com'))
if target.host in xmpp_manager.muc_domains:
elements.append(disco.DiscoIdentity('conference', 'text', 'SylkServer Chat Service'))
elements.append(disco.DiscoFeature('http://jabber.org/protocol/muc'))
elements.append(disco.DiscoFeature('urn:ietf:rfc:3264'))
elements.append(disco.DiscoFeature('urn:xmpp:coin'))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP_AUDIO))
#elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP_VIDEO))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_ICE_UDP_TRANSPORT))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_RAW_UDP_TRANSPORT))
if target.user:
# We can't say much more here, because the actual conference may end up on a different server
elements.append(disco.DiscoFeature('muc_temporary'))
elements.append(disco.DiscoFeature('muc_unmoderated'))
else:
elements.append(disco.DiscoFeature(ping.NS_PING))
if not target.user:
elements.append(disco.DiscoIdentity('gateway', 'simple', 'SylkServer'))
elements.append(disco.DiscoIdentity('server', 'im', 'SylkServer'))
else:
elements.append(disco.DiscoIdentity('client', 'pc'))
elements.append(disco.DiscoFeature('http://jabber.org/protocol/caps'))
elements.append(disco.DiscoFeature('http://jabber.org/protocol/chatstates'))
elements.append(disco.DiscoFeature('urn:ietf:rfc:3264'))
elements.append(disco.DiscoFeature('urn:xmpp:coin'))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP_AUDIO))
#elements.append(disco.DiscoFeature(jingle.NS_JINGLE_APPS_RTP_VIDEO))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_ICE_UDP_TRANSPORT))
elements.append(disco.DiscoFeature(jingle.NS_JINGLE_RAW_UDP_TRANSPORT))
return defer.succeed(elements)
def items(self, requestor, target, nodeIdentifier):
"""
Gather data for a disco items request.
@param requestor: The entity that sent the request.
@type requestor: L{JID}
@param target: The entity the request was sent to.
@type target: L{JID}
@param nodeIdentifier: The optional node being queried, or C{''}.
@type nodeIdentifier: C{unicode}
@return: Deferred with the gathered results from sibling handlers.
@rtype: L{defer.Deferred}
"""
xmpp_manager = self.parent.manager
items = []
if not target.user and target.host in xmpp_manager.domains:
items.append(disco.DiscoItem(JID('%s.%s' % (XMPPGatewayConfig.muc_prefix, target.host)), name='Multi-User Chat'))
return defer.succeed(items)
class JingleProtocol(jingle.JingleHandler):
# Functions here need to return immediately so that the IQ result is sent, so schedule them in the reactor
# TODO: review and remove this, just post notifications?
def onSessionInitiate(self, request):
reactor.callLater(0, NotificationCenter().post_notification,
'XMPPGotJingleSessionInitiate',
sender=self.parent,
data=NotificationData(stanza=request, protocol=self))
def onSessionTerminate(self, request):
reactor.callLater(0, NotificationCenter().post_notification,
'XMPPGotJingleSessionTerminate',
sender=self.parent,
data=NotificationData(stanza=request))
def onSessionAccept(self, request):
reactor.callLater(0, NotificationCenter().post_notification,
'XMPPGotJingleSessionAccept',
sender=self.parent,
data=NotificationData(stanza=request))
def onSessionInfo(self, request):
reactor.callLater(0, NotificationCenter().post_notification,
'XMPPGotJingleSessionInfo',
sender=self.parent,
data=NotificationData(stanza=request))
def onDescriptionInfo(self, request):
reactor.callLater(0, NotificationCenter().post_notification,
'XMPPGotJingleDescriptionInfo',
sender=self.parent,
data=NotificationData(stanza=request))
def onTransportInfo(self, request):
reactor.callLater(0, NotificationCenter().post_notification,
'XMPPGotJingleTransportInfo',
sender=self.parent,
data=NotificationData(stanza=request))
class MUCPresenceProtocol(xmppim.PresenceProtocol):
"""Protocol implementation to handle presence subscription to MUC URIs
"""
def subscribeReceived(self, stanza):
"""
Subscription request was received.
"""
self.subscribed(stanza.sender, sender=stanza.recipient)
self.send_available(stanza)
def unsubscribeReceived(self, stanza):
"""
Unsubscription request was received.
"""
self.unsubscribed(stanza.sender, sender=stanza.recipient)
def probeReceived(self, stanza):
"""
Probe presence was received.
"""
self.send_available(stanza)
def send_available(self, stanza):
sender_uri = FrozenURI.parse('xmpp:'+stanza.element['from'])
sender = Identity(sender_uri)
recipient_uri = FrozenURI.parse('xmpp:'+stanza.element['to'])
recipient = Identity(recipient_uri)
available = AvailabilityPresence(sender=recipient, recipient=sender)
self.send(available.to_xml_element())
diff --git a/sylk/applications/xmppgateway/xmpp/server.py b/sylk/applications/xmppgateway/xmpp/server.py
index 443c63e..9dbd361 100644
--- a/sylk/applications/xmppgateway/xmpp/server.py
+++ b/sylk/applications/xmppgateway/xmpp/server.py
@@ -1,149 +1,147 @@
-# Copyright (C) 2013 AG Projects. See LICENSE for details
-#
from sipsimple.util import ISOTimestamp
from twisted.internet import defer, reactor
from twisted.words.protocols.jabber import error, xmlstream
from twisted.words.protocols.jabber.jid import internJID
from wokkel.component import InternalComponent, Router
from wokkel.server import XMPPS2SServerFactory, DeferredS2SClientFactory
from sylk.applications.xmppgateway.configuration import XMPPGatewayConfig
from sylk.applications.xmppgateway.xmpp.logger import Logger
__all__ = ['SylkRouter', 'SylkInternalComponent', 'SylkS2SServerFactory', 'xmpp_logger']
xmpp_logger = Logger()
class SylkInternalComponent(InternalComponent):
def __init__(self, *args, **kwargs):
InternalComponent.__init__(self, *args, **kwargs)
self._iqDeferreds = {}
def startService(self):
InternalComponent.startService(self)
self.xmlstream.addObserver('/iq[@type="result"]', self._onIQResponse)
self.xmlstream.addObserver('/iq[@type="error"]', self._onIQResponse)
def stopService(self):
InternalComponent.stopService(self)
iqDeferreds = self._iqDeferreds
self._iqDeferreds = {}
for d in iqDeferreds.itervalues():
d.errback(xmlstream.TimeoutError("Shutting down"))
def request(self, request):
if (request.stanzaKind != 'iq' or request.stanzaType not in ('get', 'set')):
return defer.fail(ValueError("Not a request"))
element = request.toElement()
# Make sure we have a trackable id on the stanza
if not request.stanzaID:
element.addUniqueId()
request.stanzaID = element['id']
# Set up iq response tracking
d = defer.Deferred()
self._iqDeferreds[element['id']] = d
timeout = getattr(request, 'timeout', None)
if timeout is not None:
def onTimeout():
del self._iqDeferreds[element['id']]
d.errback(xmlstream.TimeoutError("IQ timed out"))
call = reactor.callLater(timeout, onTimeout)
def cancelTimeout(result):
if call.active():
call.cancel()
return result
d.addBoth(cancelTimeout)
self.send(element)
return d
def _onIQResponse(self, iq):
try:
d = self._iqDeferreds[iq["id"]]
except KeyError:
return
del self._iqDeferreds[iq["id"]]
iq.handled = True
if iq['type'] == 'error':
d.errback(error.exceptionFromStanza(iq))
else:
d.callback(iq)
class SylkRouter(Router):
def route(self, stanza):
"""
Route a stanza. (subclassed to avoid vebose logging)
@param stanza: The stanza to be routed.
@type stanza: L{domish.Element}.
"""
destination = internJID(stanza['to'])
if destination.host in self.routes:
self.routes[destination.host].send(stanza)
else:
self.routes[None].send(stanza)
class SylkS2SServerFactory(XMPPS2SServerFactory):
noisy = False
def onConnectionMade(self, xs):
super(self.__class__, self).onConnectionMade(xs)
def logDataIn(buf):
buf = buf.strip()
if buf:
xmpp_logger.msg("RECEIVED", ISOTimestamp.now(), buf)
def logDataOut(buf):
buf = buf.strip()
if buf:
xmpp_logger.msg("SENDING", ISOTimestamp.now(), buf)
if XMPPGatewayConfig.trace_xmpp:
xs.rawDataInFn = logDataIn
xs.rawDataOutFn = logDataOut
class DeferredS2SClientFactory(DeferredS2SClientFactory):
noisy = False
def onConnectionMade(self, xs):
super(self.__class__, self).onConnectionMade(xs)
def logDataIn(buf):
buf = buf.strip()
if buf:
xmpp_logger.msg("RECEIVED", ISOTimestamp.now(), buf)
def logDataOut(buf):
buf = buf.strip()
if buf:
xmpp_logger.msg("SENDING", ISOTimestamp.now(), buf)
if XMPPGatewayConfig.trace_xmpp:
xs.rawDataInFn = logDataIn
xs.rawDataOutFn = logDataOut
# Patch Wokkel's DeferredS2SClientFactory to use our logger
import wokkel.server
wokkel.server.DeferredS2SClientFactory = DeferredS2SClientFactory
del wokkel.server
diff --git a/sylk/applications/xmppgateway/xmpp/session.py b/sylk/applications/xmppgateway/xmpp/session.py
index 3ce78b0..53d499d 100644
--- a/sylk/applications/xmppgateway/xmpp/session.py
+++ b/sylk/applications/xmppgateway/xmpp/session.py
@@ -1,216 +1,214 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.descriptor import WriteOnceAttribute
from application.python.types import Singleton
from eventlib import coros, proc
from twisted.internet import reactor
from zope.interface import implements
from sylk.applications.xmppgateway.xmpp.stanzas import ChatMessage, ChatComposingIndication, MessageReceipt, ErrorStanza, GroupChatMessage, MUCAvailabilityPresence
__all__ = ['XMPPChatSession', 'XMPPChatSessionManager', 'XMPPIncomingMucSession', 'XMPPMucSessionManager']
# Chat sessions
class XMPPChatSession(object):
local_identity = WriteOnceAttribute()
remote_identity = WriteOnceAttribute()
def __init__(self, local_identity, remote_identity):
self.local_identity = local_identity
self.remote_identity = remote_identity
self.state = None
self.pending_receipts = {}
self.channel = coros.queue()
self._proc = None
from sylk.applications.xmppgateway.xmpp import XMPPManager
self.xmpp_manager = XMPPManager()
def start(self):
NotificationCenter().post_notification('XMPPChatSessionDidStart', sender=self)
self._proc = proc.spawn(self._run)
self.state = 'started'
def end(self):
self.send_composing_indication('gone')
self._clear_pending_receipts()
self._proc.kill()
self._proc = None
NotificationCenter().post_notification('XMPPChatSessionDidEnd', sender=self, data=NotificationData(originator='local'))
self.state = 'terminated'
def send_message(self, body, html_body, message_id=None, use_receipt=True):
message = ChatMessage(self.local_identity, self.remote_identity, body, html_body, id=message_id, use_receipt=use_receipt)
self.xmpp_manager.send_stanza(message)
if message_id is not None:
timer = reactor.callLater(30, self._receipt_timer_expired, message_id)
self.pending_receipts[message_id] = timer
NotificationCenter().post_notification('XMPPChatSessionDidSendMessage', sender=self, data=NotificationData(message=message))
def send_composing_indication(self, state, message_id=None, use_receipt=False):
message = ChatComposingIndication(self.local_identity, self.remote_identity, state, id=message_id, use_receipt=use_receipt)
self.xmpp_manager.send_stanza(message)
if message_id is not None:
timer = reactor.callLater(30, self._receipt_timer_expired, message_id)
self.pending_receipts[message_id] = timer
NotificationCenter().post_notification('XMPPChatSessionDidSendMessage', sender=self, data=NotificationData(message=message))
def send_receipt_acknowledgement(self, receipt_id):
message = MessageReceipt(self.local_identity, self.remote_identity, receipt_id)
self.xmpp_manager.send_stanza(message)
def send_error(self, stanza, error_type, conditions):
message = ErrorStanza.from_stanza(stanza, error_type, conditions)
self.xmpp_manager.send_stanza(message)
def _run(self):
notification_center = NotificationCenter()
while True:
item = self.channel.wait()
if isinstance(item, ChatMessage):
notification_center.post_notification('XMPPChatSessionGotMessage', sender=self, data=NotificationData(message=item))
elif isinstance(item, ChatComposingIndication):
if item.state == 'gone':
self._clear_pending_receipts()
notification_center.post_notification('XMPPChatSessionDidEnd', sender=self, data=NotificationData(originator='remote'))
self.state = 'terminated'
break
else:
notification_center.post_notification('XMPPChatSessionGotComposingIndication', sender=self, data=NotificationData(message=item))
elif isinstance(item, MessageReceipt):
if item.receipt_id in self.pending_receipts:
timer = self.pending_receipts.pop(item.receipt_id)
timer.cancel()
notification_center.post_notification('XMPPChatSessionDidDeliverMessage', sender=self, data=NotificationData(message_id=item.receipt_id))
elif isinstance(item, ErrorStanza):
if item.id in self.pending_receipts:
timer = self.pending_receipts.pop(item.id)
timer.cancel()
# TODO: translate cause
notification_center.post_notification('XMPPChatSessionDidNotDeliverMessage', sender=self, data=NotificationData(message_id=item.id, code=503, reason='Service Unavailable'))
self._proc = None
def _receipt_timer_expired(self, message_id):
self.pending_receipts.pop(message_id)
NotificationCenter().post_notification('XMPPChatSessionDidNotDeliverMessage', sender=self, data=NotificationData(message_id=message_id, code=408, reason='Timeout'))
def _clear_pending_receipts(self):
notification_center = NotificationCenter()
while self.pending_receipts:
message_id, timer = self.pending_receipts.popitem()
timer.cancel()
notification_center.post_notification('XMPPChatSessionDidNotDeliverMessage', sender=self, data=NotificationData(message_id=message_id, code=408, reason='Timeout'))
class XMPPChatSessionManager(object):
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
self.sessions = {}
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='XMPPChatSessionDidStart')
notification_center.add_observer(self, name='XMPPChatSessionDidEnd')
def stop(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self, name='XMPPChatSessionDidStart')
notification_center.remove_observer(self, name='XMPPChatSessionDidEnd')
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_XMPPChatSessionDidStart(self, notification):
session = notification.sender
self.sessions[(session.local_identity.uri, session.remote_identity.uri)] = session
def _NH_XMPPChatSessionDidEnd(self, notification):
session = notification.sender
del self.sessions[(session.local_identity.uri, session.remote_identity.uri)]
# MUC sessions
class XMPPIncomingMucSession(object):
local_identity = WriteOnceAttribute()
remote_identity = WriteOnceAttribute()
def __init__(self, local_identity, remote_identity):
self.local_identity = local_identity
self.remote_identity = remote_identity
self.state = None
self.channel = coros.queue()
self._proc = None
from sylk.applications.xmppgateway.xmpp import XMPPManager
self.xmpp_manager = XMPPManager()
def start(self):
NotificationCenter().post_notification('XMPPIncomingMucSessionDidStart', sender=self)
self._proc = proc.spawn(self._run)
self.state = 'started'
def end(self):
self._proc.kill()
self._proc = None
NotificationCenter().post_notification('XMPPIncomingMucSessionDidEnd', sender=self, data=NotificationData(originator='local'))
self.state = 'terminated'
def send_message(self, sender, body, html_body, message_id=None):
# TODO: timestamp?
message = GroupChatMessage(sender, self.remote_identity, body, html_body, id=message_id)
self.xmpp_manager.send_muc_stanza(message)
def _run(self):
notification_center = NotificationCenter()
while True:
item = self.channel.wait()
if isinstance(item, GroupChatMessage):
notification_center.post_notification('XMPPIncomingMucSessionGotMessage', sender=self, data=NotificationData(message=item))
elif isinstance(item, MUCAvailabilityPresence):
if item.available:
nickname = item.recipient.uri.resource
notification_center.post_notification('XMPPIncomingMucSessionChangedNickname', sender=self, data=NotificationData(stanza=item, nickname=nickname))
else:
notification_center.post_notification('XMPPIncomingMucSessionDidEnd', sender=self, data=NotificationData(originator='local'))
self.state = 'terminated'
break
self._proc = None
class XMPPMucSessionManager(object):
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
self.incoming = {}
self.outgoing = {}
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='XMPPIncomingMucSessionDidStart')
notification_center.add_observer(self, name='XMPPIncomingMucSessionDidEnd')
def stop(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self, name='XMPPIncomingMucSessionDidStart')
notification_center.remove_observer(self, name='XMPPIncomingMucSessionDidEnd')
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_XMPPIncomingMucSessionDidStart(self, notification):
muc = notification.sender
self.incoming[(muc.local_identity.uri, muc.remote_identity.uri)] = muc
def _NH_XMPPIncomingMucSessionDidEnd(self, notification):
muc = notification.sender
del self.incoming[(muc.local_identity.uri, muc.remote_identity.uri)]
diff --git a/sylk/applications/xmppgateway/xmpp/stanzas/__init__.py b/sylk/applications/xmppgateway/xmpp/stanzas/__init__.py
index d815987..2a3b3e0 100644
--- a/sylk/applications/xmppgateway/xmpp/stanzas/__init__.py
+++ b/sylk/applications/xmppgateway/xmpp/stanzas/__init__.py
@@ -1,285 +1,283 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
import hashlib
from twisted.words.xish import domish
from sylk import __version__ as SYLK_VERSION
from sylk.applications.xmppgateway.util import html2text
CHATSTATES_NS = 'http://jabber.org/protocol/chatstates'
RECEIPTS_NS = 'urn:xmpp:receipts'
STANZAS_NS = 'urn:ietf:params:xml:ns:xmpp-stanzas'
XML_NS = 'http://www.w3.org/XML/1998/namespace'
MUC_NS = 'http://jabber.org/protocol/muc'
MUC_USER_NS = MUC_NS + '#user'
CAPS_NS = 'http://jabber.org/protocol/caps'
SYLK_HASH = hashlib.sha1('SylkServer-%s' % SYLK_VERSION).hexdigest()
SYLK_CAPS = []
class BaseStanza(object):
stanza_type = None # to be defined by subclasses
type = None
def __init__(self, sender, recipient, id=None):
self.sender = sender
self.recipient = recipient
self.id = id
def to_xml_element(self):
xml_element = domish.Element((None, self.stanza_type))
xml_element['from'] = unicode(self.sender.uri.as_xmpp_jid())
xml_element['to'] = unicode(self.recipient.uri.as_xmpp_jid())
if self.type:
xml_element['type'] = self.type
if self.id is not None:
xml_element['id'] = self.id
return xml_element
class ErrorStanza(object):
"""
Stanza representing an error of another stanza. It's not a base stanza type on its own.
"""
def __init__(self, stanza_type, sender, recipient, error_type, conditions, id=None):
self.stanza_type = stanza_type
self.sender = sender
self.recipient = recipient
self.id = id
self.conditions = conditions
self.error_type = error_type
@classmethod
def from_stanza(cls, stanza, error_type, conditions):
# In error stanzas sender and recipient are swapped
return cls(stanza.stanza_type, stanza.recipient, stanza.sender, error_type, conditions, id=stanza.id)
def to_xml_element(self):
xml_element = domish.Element((None, self.stanza_type))
xml_element['from'] = unicode(self.sender.uri.as_xmpp_jid())
xml_element['to'] = unicode(self.recipient.uri.as_xmpp_jid())
xml_element['type'] = 'error'
if self.id is not None:
xml_element['id'] = self.id
error_element = domish.Element((None, 'error'))
error_element['type'] = self.error_type
[error_element.addChild(domish.Element((ns, condition))) for condition, ns in self.conditions]
xml_element.addChild(error_element)
return xml_element
class BaseMessageStanza(BaseStanza):
stanza_type = 'message'
def __init__(self, sender, recipient, body=None, html_body=None, id=None, use_receipt=False):
super(BaseMessageStanza, self).__init__(sender, recipient, id=id)
self.use_receipt = use_receipt
if body is not None and html_body is None:
self.body = body
self.html_body = None
elif body is None and html_body is not None:
self.body = html2text(html_body)
self.html_body = html_body
else:
self.body = body
self.html_body = html_body
def to_xml_element(self):
xml_element = super(BaseMessageStanza, self).to_xml_element()
if self.id is not None and self.recipient.uri.resource is not None and self.use_receipt:
xml_element.addElement('request', defaultUri=RECEIPTS_NS)
if self.body is not None:
xml_element.addElement('body', content=self.body)
if self.html_body is not None:
xml_element.addElement('html', content=self.html_body)
return xml_element
class NormalMessage(BaseMessageStanza):
def __init__(self, sender, recipient, body=None, html_body=None, id=None, use_receipt=False):
if body is None and html_body is None:
raise ValueError('either body or html_body need to be set')
super(NormalMessage, self).__init__(sender, recipient, body, html_body, id, use_receipt)
class ChatMessage(BaseMessageStanza):
type = 'chat'
def __init__(self, sender, recipient, body=None, html_body=None, id=None, use_receipt=True):
if body is None and html_body is None:
raise ValueError('either body or html_body need to be set')
super(ChatMessage, self).__init__(sender, recipient, body, html_body, id, use_receipt)
def to_xml_element(self):
xml_element = super(ChatMessage, self).to_xml_element()
xml_element.addElement('active', defaultUri=CHATSTATES_NS)
return xml_element
class ChatComposingIndication(BaseMessageStanza):
type = 'chat'
def __init__(self, sender, recipient, state, id=None, use_receipt=False):
super(ChatComposingIndication, self).__init__(sender, recipient, id=id, use_receipt=use_receipt)
self.state = state
def to_xml_element(self):
xml_element = super(ChatComposingIndication, self).to_xml_element()
xml_element.addElement(self.state, defaultUri=CHATSTATES_NS)
return xml_element
class GroupChatMessage(BaseMessageStanza):
type = 'groupchat'
def __init__(self, sender, recipient, body=None, html_body=None, id=None):
# TODO: add timestamp
if body is None and html_body is None:
raise ValueError('either body or html_body need to be set')
super(GroupChatMessage, self).__init__(sender, recipient, body, html_body, id, False)
class MessageReceipt(BaseMessageStanza):
def __init__(self, sender, recipient, receipt_id, id=None):
super(MessageReceipt, self).__init__(sender, recipient, id=id, use_receipt=False)
self.receipt_id = receipt_id
def to_xml_element(self):
xml_element = super(MessageReceipt, self).to_xml_element()
receipt_element = domish.Element((RECEIPTS_NS, 'received'))
receipt_element['id'] = self.receipt_id
xml_element.addChild(receipt_element)
return xml_element
class BasePresenceStanza(BaseStanza):
stanza_type = 'presence'
class IncomingInvitationMessage(BaseMessageStanza):
def __init__(self, sender, recipient, invited_user, reason=None, id=None):
super(IncomingInvitationMessage, self).__init__(sender, recipient, body=None, html_body=None, id=id, use_receipt=False)
self.invited_user = invited_user
self.reason = reason
def to_xml_element(self):
xml_element = super(IncomingInvitationMessage, self).to_xml_element()
child = xml_element.addElement((MUC_USER_NS, 'x'))
child.addElement('invite')
child.invite['to'] = unicode(self.invited_user.uri.as_xmpp_jid())
if self.reason:
child.invite.addElement('reason', content=self.reason)
return xml_element
class OutgoingInvitationMessage(BaseMessageStanza):
def __init__(self, sender, recipient, originator, reason=None, id=None):
super(OutgoingInvitationMessage, self).__init__(sender, recipient, body=None, html_body=None, id=id, use_receipt=False)
self.originator = originator
self.reason = reason
def to_xml_element(self):
xml_element = super(OutgoingInvitationMessage, self).to_xml_element()
child = xml_element.addElement((MUC_USER_NS, 'x'))
child.addElement('invite')
child.invite['from'] = unicode(self.originator.uri.as_xmpp_jid())
if self.reason:
child.invite.addElement('reason', content=self.reason)
return xml_element
class AvailabilityPresence(BasePresenceStanza):
def __init__(self, sender, recipient, available=True, show=None, statuses=None, priority=0, id=None):
super(AvailabilityPresence, self).__init__(sender, recipient, id=id)
self.available = available
self.show = show
self.priority = priority
self.statuses = statuses or {}
def _get_available(self):
return self.__dict__['available']
def _set_available(self, available):
if available:
self.type = None
else:
self.type = 'unavailable'
self.__dict__['available'] = available
available = property(_get_available, _set_available)
del _get_available, _set_available
@property
def status(self):
status = self.statuses.get(None)
if status is None:
try:
status = next(self.statuses.itervalues())
except StopIteration:
pass
return status
def to_xml_element(self):
xml_element = super(BasePresenceStanza, self).to_xml_element()
if self.available:
if self.show is not None:
xml_element.addElement('show', content=self.show)
if self.priority != 0:
xml_element.addElement('priority', content=unicode(self.priority))
caps = xml_element.addElement('c', defaultUri=CAPS_NS)
caps['node'] = 'http://sylkserver.com'
caps['hash'] = 'sha-1'
caps['ver'] = SYLK_HASH
if SYLK_CAPS:
caps['ext'] = ' '.join(SYLK_CAPS)
for lang, text in self.statuses.iteritems():
status = xml_element.addElement('status', content=text)
if lang:
status[(XML_NS, 'lang')] = lang
return xml_element
class SubscriptionPresence(BasePresenceStanza):
def __init__(self, sender, recipient, type, id=None):
super(SubscriptionPresence, self).__init__(sender, recipient, id=id)
self.type = type
class ProbePresence(BasePresenceStanza):
type = 'probe'
class MUCAvailabilityPresence(AvailabilityPresence):
def __init__(self, sender, recipient, available=True, show=None, statuses=None, priority=0, id=None, affiliation=None, jid=None, role=None, muc_statuses=None):
super(MUCAvailabilityPresence, self).__init__(sender, recipient, available, show, statuses, priority, id)
self.affiliation = affiliation or 'member'
self.role = role or 'participant'
self.muc_statuses = muc_statuses or []
self.jid = jid
def to_xml_element(self):
xml_element = super(MUCAvailabilityPresence, self).to_xml_element()
muc = xml_element.addElement('x', defaultUri=MUC_USER_NS)
item = muc.addElement('item')
if self.affiliation:
item['affiliation'] = self.affiliation
if self.role:
item['role'] = self.role
if self.jid:
item['jid'] = unicode(self.jid.uri.as_xmpp_jid())
for code in self.muc_statuses:
status = muc.addElement('status')
status['code'] = code
return xml_element
class MUCErrorPresence(ErrorStanza):
def to_xml_element(self):
xml_element = super(MUCErrorPresence, self).to_xml_element()
xml_element.addElement('x', defaultUri=MUC_USER_NS)
return xml_element
diff --git a/sylk/applications/xmppgateway/xmpp/subscription.py b/sylk/applications/xmppgateway/xmpp/subscription.py
index e9c9d18..234e11c 100644
--- a/sylk/applications/xmppgateway/xmpp/subscription.py
+++ b/sylk/applications/xmppgateway/xmpp/subscription.py
@@ -1,200 +1,198 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from application.python.descriptor import WriteOnceAttribute
from application.python.types import Singleton
from eventlib import coros, proc
from zope.interface import implements
from sylk.applications.xmppgateway.xmpp.stanzas import SubscriptionPresence, ProbePresence, AvailabilityPresence
__all__ = ['XMPPSubscription', 'XMPPIncomingSubscription', 'XMPPSubscriptionManager']
class XMPPSubscription(object):
local_identity = WriteOnceAttribute()
remote_identity = WriteOnceAttribute()
def __init__(self, local_identity, remote_identity):
self.local_identity = local_identity
self.remote_identity = remote_identity
self.state = None
self.channel = coros.queue()
self._proc = None
from sylk.applications.xmppgateway.xmpp import XMPPManager
self.xmpp_manager = XMPPManager()
def _set_state(self, new_state):
prev_state = self.__dict__.get('state', None)
self.__dict__['state'] = new_state
if prev_state != new_state:
NotificationCenter().post_notification('XMPPSubscriptionChangedState', sender=self, data=NotificationData(prev_state=prev_state, state=new_state))
def _get_state(self):
return self.__dict__['state']
state = property(_get_state, _set_state)
del _get_state, _set_state
def start(self):
NotificationCenter().post_notification('XMPPSubscriptionDidStart', sender=self)
self._proc = proc.spawn(self._run)
self.subscribe()
def end(self):
if self.state == 'terminated':
return
self._proc.kill()
self._proc = None
NotificationCenter().post_notification('XMPPSubscriptionDidEnd', sender=self, data=NotificationData(originator='local'))
self.state = 'terminated'
def subscribe(self):
self.state = 'subscribe_sent'
stanza = SubscriptionPresence(self.local_identity, self.remote_identity, 'subscribe')
self.xmpp_manager.send_stanza(stanza)
# If we are already subscribed we may not receive an answer, send a probe just in case
self._send_probe()
def unsubscribe(self):
self.state = 'unsubscribe_sent'
stanza = SubscriptionPresence(self.local_identity, self.remote_identity, 'unsubscribe')
self.xmpp_manager.send_stanza(stanza)
def _send_probe(self):
self.state = 'subscribe_sent'
stanza = ProbePresence(self.local_identity, self.remote_identity)
self.xmpp_manager.send_stanza(stanza)
def _run(self):
notification_center = NotificationCenter()
while True:
item = self.channel.wait()
if isinstance(item, AvailabilityPresence):
if self.state == 'subscribe_sent':
self.state = 'active'
notification_center.post_notification('XMPPSubscriptionGotNotify', sender=self, data=NotificationData(presence=item))
elif isinstance(item, SubscriptionPresence):
if self.state == 'subscribe_sent' and item.type == 'subscribed':
self.state = 'active'
elif item.type == 'unsubscribed':
prev_state = self.state
self.state = 'terminated'
if prev_state in ('active', 'unsubscribe_sent'):
notification_center.post_notification('XMPPSubscriptionDidEnd', sender=self)
else:
notification_center.post_notification('XMPPSubscriptionDidFail', sender=self)
break
self._proc = None
class XMPPIncomingSubscription(object):
local_identity = WriteOnceAttribute()
remote_identity = WriteOnceAttribute()
def __init__(self, local_identity, remote_identity):
self.local_identity = local_identity
self.remote_identity = remote_identity
self.state = None
self.channel = coros.queue()
self._proc = None
from sylk.applications.xmppgateway.xmpp import XMPPManager
self.xmpp_manager = XMPPManager()
def _set_state(self, new_state):
prev_state = self.__dict__.get('state', None)
self.__dict__['state'] = new_state
if prev_state != new_state:
NotificationCenter().post_notification('XMPPIncomingSubscriptionChangedState', sender=self, data=NotificationData(prev_state=prev_state, state=new_state))
def _get_state(self):
return self.__dict__['state']
state = property(_get_state, _set_state)
del _get_state, _set_state
def start(self):
NotificationCenter().post_notification('XMPPIncomingSubscriptionDidStart', sender=self)
self._proc = proc.spawn(self._run)
def end(self):
if self.state == 'terminated':
return
self.state = 'terminated'
self._proc.kill()
self._proc = None
NotificationCenter().post_notification('XMPPIncomingSubscriptionDidEnd', sender=self, data=NotificationData(originator='local'))
def accept(self):
self.state = 'active'
stanza = SubscriptionPresence(self.local_identity, self.remote_identity, 'subscribed')
self.xmpp_manager.send_stanza(stanza)
def reject(self):
self.state = 'terminating'
stanza = SubscriptionPresence(self.local_identity, self.remote_identity, 'unsubscribed')
self.xmpp_manager.send_stanza(stanza)
self.end()
def send_presence(self, stanza):
self.xmpp_manager.send_stanza(stanza)
def _run(self):
notification_center = NotificationCenter()
while True:
item = self.channel.wait()
if isinstance(item, SubscriptionPresence):
if item.type == 'subscribe':
notification_center.post_notification('XMPPIncomingSubscriptionGotSubscribe', sender=self)
elif item.type == 'unsubscribe':
self.state = 'terminated'
notification_center = NotificationCenter()
notification_center.post_notification('XMPPIncomingSubscriptionGotUnsubscribe', sender=self)
notification_center.post_notification('XMPPIncomingSubscriptionDidEnd', sender=self, data=NotificationData(originator='local'))
break
elif isinstance(item, ProbePresence):
notification_center = NotificationCenter()
notification_center.post_notification('XMPPIncomingSubscriptionGotProbe', sender=self)
self._proc = None
class XMPPSubscriptionManager(object):
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
self.incoming_subscriptions = {}
self.outgoing_subscriptions = {}
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='XMPPSubscriptionDidStart')
notification_center.add_observer(self, name='XMPPSubscriptionDidEnd')
notification_center.add_observer(self, name='XMPPIncomingSubscriptionDidStart')
notification_center.add_observer(self, name='XMPPIncomingSubscriptionDidEnd')
def stop(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self, name='XMPPSubscriptionDidStart')
notification_center.remove_observer(self, name='XMPPSubscriptionDidEnd')
notification_center.remove_observer(self, name='XMPPIncomingSubscriptionDidStart')
notification_center.remove_observer(self, name='XMPPIncomingSubscriptionDidEnd')
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_XMPPSubscriptionDidStart(self, notification):
subscription = notification.sender
self.outgoing_subscriptions[(subscription.local_identity.uri, subscription.remote_identity.uri)] = subscription
def _NH_XMPPSubscriptionDidEnd(self, notification):
subscription = notification.sender
del self.outgoing_subscriptions[(subscription.local_identity.uri, subscription.remote_identity.uri)]
def _NH_XMPPIncomingSubscriptionDidStart(self, notification):
subscription = notification.sender
self.incoming_subscriptions[(subscription.local_identity.uri, subscription.remote_identity.uri)] = subscription
def _NH_XMPPIncomingSubscriptionDidEnd(self, notification):
subscription = notification.sender
del self.incoming_subscriptions[(subscription.local_identity.uri, subscription.remote_identity.uri)]
diff --git a/sylk/bonjour.py b/sylk/bonjour.py
index 10e35df..bf3a80e 100644
--- a/sylk/bonjour.py
+++ b/sylk/bonjour.py
@@ -1,258 +1,256 @@
-# Copyright (C) 2012 AG Projects. See LICENSE for details
-#
import uuid
from application import log
from application.notification import IObserver, NotificationCenter, NotificationData
from application.python import Null
from eventlib import api, coros, proc
from eventlib.green import select
from sipsimple.account.bonjour import _bonjour, BonjourPresenceState, BonjourRegistrationFile
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.threading import call_in_twisted_thread, run_in_twisted_thread
from sipsimple.threading.green import Command, run_in_green_thread
from threading import Lock
from twisted.internet import reactor
from zope.interface import implements
from sylk.accounts import DefaultAccount
class RestartSelect(Exception): pass
class BonjourService(object):
implements(IObserver)
def __init__(self, service='sipfocus', name='SylkServer', uri_user=None, is_focus=True):
self.account = DefaultAccount()
self.service = service
self.name = name
self.uri_user = uri_user
self.is_focus = is_focus
self.id = str(uuid.uuid4())
self._stopped = True
self._files = []
self._command_channel = coros.queue()
self._select_proc = None
self._register_timer = None
self._update_timer = None
self._lock = Lock()
self.__dict__['presence_state'] = None
@run_in_green_thread
def start(self):
notification_center = NotificationCenter()
notification_center.add_observer(self, name='NetworkConditionsDidChange')
self._select_proc = proc.spawn(self._process_files)
proc.spawn(self._handle_commands)
self._activate()
@run_in_green_thread
def stop(self):
self._deactivate()
notification_center = NotificationCenter()
notification_center.remove_observer(self, name='NetworkConditionsDidChange')
self._select_proc.kill()
self._command_channel.send_exception(api.GreenletExit)
def _activate(self):
self._stopped = False
self._command_channel.send(Command('register'))
def _deactivate(self):
command = Command('stop')
self._command_channel.send(command)
command.wait()
self._stopped = True
def restart_registration(self):
self._command_channel.send(Command('unregister'))
self._command_channel.send(Command('register'))
def update_registrations(self):
self._command_channel.send(Command('update_registrations'))
def _get_presence_state(self):
return self.__dict__['presence_state']
def _set_presence_state(self, state):
if state is not None and not isinstance(state, BonjourPresenceState):
raise ValueError("state must be a %s instance or None" % BonjourPresenceState.__name__)
with self._lock:
old_state = self.__dict__['presence_state']
self.__dict__['presence_state'] = state
if state != old_state:
call_in_twisted_thread(self.update_registrations)
presence_state = property(_get_presence_state, _set_presence_state)
del _get_presence_state, _set_presence_state
def _register_cb(self, file, flags, error_code, name, regtype, domain):
notification_center = NotificationCenter()
file = BonjourRegistrationFile.find_by_file(file)
if error_code == _bonjour.kDNSServiceErr_NoError:
notification_center.post_notification('BonjourServiceRegistrationDidSucceed', sender=self,
data=NotificationData(name=name, transport=file.transport))
else:
error = _bonjour.BonjourError(error_code)
notification_center.post_notification('BonjourServiceRegistrationDidFail', sender=self,
data=NotificationData(reason=str(error), transport=file.transport))
self._files.remove(file)
self._select_proc.kill(RestartSelect)
file.close()
if self._register_timer is None:
self._register_timer = reactor.callLater(1, self._command_channel.send, Command('register'))
def _process_files(self):
while True:
try:
ready = select.select([f for f in self._files if not f.active and not f.closed], [], [])[0]
except RestartSelect:
continue
else:
for file in ready:
file.active = True
self._command_channel.send(Command('process_results', files=[f for f in ready if not f.closed]))
def _handle_commands(self):
while True:
command = self._command_channel.wait()
if not self._stopped:
handler = getattr(self, '_CH_%s' % command.name)
handler(command)
def _CH_unregister(self, command):
if self._register_timer is not None and self._register_timer.active():
self._register_timer.cancel()
self._register_timer = None
if self._update_timer is not None and self._update_timer.active():
self._update_timer.cancel()
self._update_timer = None
old_files = []
for file in (f for f in self._files[:] if isinstance(f, BonjourRegistrationFile)):
old_files.append(file)
self._files.remove(file)
self._select_proc.kill(RestartSelect)
for file in old_files:
file.close()
notification_center = NotificationCenter()
for transport in set(file.transport for file in self._files):
notification_center.post_notification('BonjourServiceRegistrationDidEnd', sender=self, data=NotificationData(transport=transport))
command.signal()
def _CH_register(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._register_timer is not None and self._register_timer.active():
self._register_timer.cancel()
self._register_timer = None
supported_transports = set(transport for transport in settings.sip.transport_list if transport!='tls' or self.account.tls.certificate is not None)
registered_transports = set(file.transport for file in self._files if isinstance(file, BonjourRegistrationFile))
missing_transports = supported_transports - registered_transports
added_transports = set()
for transport in missing_transports:
notification_center.post_notification('BonjourServiceWillRegister', sender=self, data=NotificationData(transport=transport))
try:
contact_uri = self.account.contact[transport]
contact_uri.user = self.uri_user
if self.is_focus:
contact_uri.parameters['isfocus'] = None
txtdata = dict(txtvers=1, name=self.name, contact="<%s>" % str(contact_uri), instance_id=self.id)
state = self.presence_state
if state is not None:
txtdata['state'] = state.state
txtdata['note'] = state.note.encode('utf-8')
file = _bonjour.DNSServiceRegister(name=str(contact_uri),
regtype="_%s._%s" % (self.service, transport if transport == 'udp' else 'tcp'),
port=contact_uri.port,
callBack=self._register_cb,
txtRecord=_bonjour.TXTRecord(items=txtdata))
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourServiceRegistrationDidFail', sender=self,
data=NotificationData(reason=str(e), transport=transport))
else:
self._files.append(BonjourRegistrationFile(file, transport))
added_transports.add(transport)
if added_transports:
self._select_proc.kill(RestartSelect)
if added_transports != missing_transports:
self._register_timer = reactor.callLater(1, self._command_channel.send, Command('register', command.event))
else:
command.signal()
def _CH_update_registrations(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
if self._update_timer is not None and self._update_timer.active():
self._update_timer.cancel()
self._update_timer = None
available_transports = settings.sip.transport_list
old_files = []
for file in (f for f in self._files[:] if isinstance(f, BonjourRegistrationFile) and f.transport not in available_transports):
old_files.append(file)
self._files.remove(file)
self._select_proc.kill(RestartSelect)
for file in old_files:
file.close()
update_failure = False
for file in (f for f in self._files if isinstance(f, BonjourRegistrationFile)):
try:
contact_uri = self.account.contact[file.transport]
contact_uri.user = self.uri_user
if self.is_focus:
contact_uri.parameters['isfocus'] = None
txtdata = dict(txtvers=1, name=self.name, contact="<%s>" % str(contact_uri), instance_id=self.id)
state = self.presence_state
if state is not None:
txtdata['state'] = state.state
txtdata['note'] = state.note.encode('utf-8')
_bonjour.DNSServiceUpdateRecord(file.file, None, flags=0, rdata=_bonjour.TXTRecord(items=txtdata), ttl=0)
except (_bonjour.BonjourError, KeyError), e:
notification_center.post_notification('BonjourServiceRegistrationUpdateDidFail', sender=self,
data=NotificationData(reason=str(e), transport=file.transport))
update_failure = True
self._command_channel.send(Command('register'))
if update_failure:
self._update_timer = reactor.callLater(1, self._command_channel.send, Command('update_registrations', command.event))
else:
command.signal()
def _CH_process_results(self, command):
for file in (f for f in command.files if not f.closed):
try:
_bonjour.DNSServiceProcessResult(file.file)
except:
# Should we close the file? The documentation doesn't say anything about this. -Luci
log.err()
for file in command.files:
file.active = False
self._files = [f for f in self._files if not f.closed]
self._select_proc.kill(RestartSelect)
def _CH_stop(self, command):
if self._register_timer is not None and self._register_timer.active():
self._register_timer.cancel()
self._register_timer = None
if self._update_timer is not None and self._update_timer.active():
self._update_timer.cancel()
self._update_timer = None
old_files = self._files
self._files = []
self._select_proc.kill(RestartSelect)
for file in old_files:
file.close()
notification_center = NotificationCenter()
for transport in set(file.transport for file in self._files):
notification_center.post_notification('BonjourServiceRegistrationDidEnd', sender=self, data=NotificationData(transport=transport))
command.signal()
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_NetworkConditionsDidChange(self, notification):
if self._files:
self.restart_registration()
diff --git a/sylk/configuration/__init__.py b/sylk/configuration/__init__.py
index 90249b8..2c0514e 100644
--- a/sylk/configuration/__init__.py
+++ b/sylk/configuration/__init__.py
@@ -1,88 +1,86 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
from application.configuration import ConfigSection, ConfigSetting
from application.configuration.datatypes import NetworkRangeList, StringList
from application.system import host
from sipsimple.configuration.datatypes import NonNegativeInteger, SampleRate
from sylk import configuration_filename
from sylk.configuration.datatypes import AudioCodecs, IPAddress, Path, Port, PortRange, SIPProxyAddress, SRTPEncryption
from sylk.resources import Resources, VarResources
from sylk.tls import Certificate, PrivateKey
class ServerConfig(ConfigSection):
__cfgfile__ = configuration_filename
__section__ = 'Server'
ca_file = ConfigSetting(type=Path, value=Path(Resources.get('tls/ca.crt')))
certificate = ConfigSetting(type=Path, value=Path(Resources.get('tls/default.crt')))
verify_server = False
enable_bonjour = False
default_application = 'conference'
application_map = ConfigSetting(type=StringList, value=['echo:echo'])
disabled_applications = ConfigSetting(type=StringList, value='')
extra_applications_dir = ConfigSetting(type=Path, value=None)
trace_dir = ConfigSetting(type=Path, value=Path(VarResources.get('log/sylkserver')))
trace_core = False
trace_sip = False
trace_msrp = False
trace_notifications = False
spool_dir = ConfigSetting(type=Path, value=Path(VarResources.get('spool/sylkserver')))
class SIPConfig(ConfigSection):
__cfgfile__ = configuration_filename
__section__ = 'SIP'
local_ip = ConfigSetting(type=IPAddress, value=IPAddress(host.default_ip))
local_udp_port = ConfigSetting(type=Port, value=5060)
local_tcp_port = ConfigSetting(type=Port, value=5060)
local_tls_port = ConfigSetting(type=Port, value=5061)
advertised_ip = ConfigSetting(type=IPAddress, value=None)
outbound_proxy = ConfigSetting(type=SIPProxyAddress, value=None)
trusted_peers = ConfigSetting(type=NetworkRangeList, value=NetworkRangeList('any'))
enable_ice = False
class MSRPConfig(ConfigSection):
__cfgfile__ = configuration_filename
__section__ = 'MSRP'
use_tls = True
class RTPConfig(ConfigSection):
__cfgfile__ = configuration_filename
__section__ = 'RTP'
audio_codecs = ConfigSetting(type=AudioCodecs, value=['opus', 'speex', 'G722', 'PCMA', 'PCMU'])
port_range = ConfigSetting(type=PortRange, value=PortRange('50000:50500'))
srtp_encryption = ConfigSetting(type=SRTPEncryption, value='opportunistic')
timeout = ConfigSetting(type=NonNegativeInteger, value=30)
sample_rate = ConfigSetting(type=SampleRate, value=32000)
class WebServerConfig(ConfigSection):
__cfgfile__ = configuration_filename
__section__ = 'WebServer'
local_ip = ConfigSetting(type=IPAddress, value=IPAddress(host.default_ip))
local_port = ConfigSetting(type=Port, value=10888)
hostname = ''
certificate = ConfigSetting(type=Path, value=Path(Resources.get('tls/default.crt')))
class ThorNodeConfig(ConfigSection):
__cfgfile__ = configuration_filename
__section__ = 'ThorNetwork'
enabled = False
domain = "sipthor.net"
multiply = 1000
certificate = ConfigSetting(type=Certificate, value=None)
private_key = ConfigSetting(type=PrivateKey, value=None)
ca = ConfigSetting(type=Certificate, value=None)
diff --git a/sylk/configuration/datatypes.py b/sylk/configuration/datatypes.py
index a5aedb2..283864f 100644
--- a/sylk/configuration/datatypes.py
+++ b/sylk/configuration/datatypes.py
@@ -1,180 +1,178 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
import os
import re
import socket
import sys
import urllib
import urlparse
from application.python.descriptor import classproperty
from application.system import host
from sipsimple.configuration.datatypes import AudioCodecList, Hostname, SIPTransport
class AudioCodecs(list):
def __new__(cls, value):
if isinstance(value, (tuple, list)):
return [str(x) for x in value if x in AudioCodecList.available_values] or None
elif isinstance(value, basestring):
if value.lower() in ('none', ''):
return None
return [x for x in re.split(r'\s*,\s*', value) if x in AudioCodecList.available_values] or None
else:
raise TypeError("value must be a string, list or tuple")
class IPAddress(str):
"""An IP address in quad dotted number notation"""
def __new__(cls, value):
try:
socket.inet_aton(value)
except socket.error:
raise ValueError("invalid IP address: %r" % value)
except TypeError:
raise TypeError("value must be a string")
return str.__new__(cls, value)
@property
def normalized(self):
if self == '0.0.0.0':
return host.default_ip or '127.0.0.1'
return str(self)
class Port(int):
def __new__(cls, value):
try:
value = int(value)
except ValueError:
return None
if not (0 <= value <= 65535):
raise ValueError("illegal port value: %s" % value)
return value
class PortRange(object):
"""A port range in the form start:end with start and end being even numbers in the [1024, 65536] range"""
def __init__(self, value):
self.start, self.end = [int(p) for p in value.split(':', 1)]
allowed = xrange(1024, 65537, 2)
if not (self.start in allowed and self.end in allowed and self.start < self.end):
raise ValueError("bad range: %r: ports must be even numbers in the range [1024, 65536] with start < end" % value)
class SIPProxyAddress(object):
_description_re = re.compile(r"^(?P(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})|([a-zA-Z0-9\-_]+(\.[a-zA-Z0-9\-_]+)*))(:(?P\d+))?(;transport=(?P.+))?$")
def __new__(cls, description):
if not description:
return None
if not cls._description_re.match(description):
raise ValueError("illegal SIP proxy address: %s" % description)
return super(SIPProxyAddress, cls).__new__(cls)
def __init__(self, description):
match = self.__class__._description_re.match(description)
data = match.groupdict()
host = data.get('host')
port = data.get('port', None) or 5060
transport = data.get('transport', None) or 'udp'
self.host = Hostname(host)
self.port = Port(port)
if self.port == 0:
raise ValueError("illegal port value: 0")
self.transport = SIPTransport(transport)
def __getstate__(self):
return unicode(self)
def __setstate__(self, state):
if not self.__class__._description_re.match(state):
raise ValueError("illegal SIP proxy address: %s" % state)
self.__init__(state)
def __eq__(self, other):
try:
return (self.host, self.port, self.transport) == (other.host, other.port, other.transport)
except AttributeError:
return False
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return hash((self.host, self.port, self.transport))
def __unicode__(self):
return u'%s:%d;transport=%s' % (self.host, self.port, self.transport)
class Path(unicode):
def __new__(cls, path):
if path:
path = os.path.normpath(path)
return unicode.__new__(cls, path)
@property
def normalized(self):
return os.path.expanduser(self)
class URL(object):
"""A class describing an URL and providing access to its elements"""
def __init__(self, url):
scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
if netloc:
if "@" in netloc:
userinfo, hostport = netloc.split("@", 1)
if ":" in userinfo:
username, password = userinfo.split(":", 1)
else:
username, password = userinfo, None
else:
username = password = None
hostport = netloc
if ':' in hostport:
host, port = hostport.split(':', 1)
else:
host, port = hostport, None
else:
username = password = host = port = None
self.original_url = url
self.scheme = scheme
self.username = username
self.password = password
self.host = host
self.port = int(port) if port is not None else None
self.path = urllib.url2pathname(path)
self.query_items = dict(urlparse.parse_qsl(query))
self.fragment = fragment
def __str__(self):
return urlparse.urlunsplit((self.scheme, self.netloc, urllib.pathname2url(self.path), self.query, self.fragment))
def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.__str__())
url = property(__str__)
@property
def query(self):
return urllib.urlencode(self.query_items)
@property
def netloc(self):
authinfo = ':'.join(str(x) for x in (self.username, self.password) if x is not None) or None
hostport = ':'.join(str(x) for x in (self.host or '', self.port) if x is not None)
return '@'.join(x for x in (authinfo, hostport) if x is not None)
class SRTPEncryption(str):
available_values = ('opportunistic', 'sdes', 'zrtp', 'disabled')
def __new__(cls, value):
value = str(value)
if value not in cls.available_values:
raise ValueError("illegal value for SRTP encryption: %s" % value)
return value
diff --git a/sylk/configuration/settings.py b/sylk/configuration/settings.py
index a580f51..5471268 100644
--- a/sylk/configuration/settings.py
+++ b/sylk/configuration/settings.py
@@ -1,171 +1,169 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
"""
SIP SIMPLE SDK settings extensions.
"""
__all__ = ['AccountExtension', 'BonjourAccountExtension', 'SylkServerSettingsExtension']
import os
from application import log
from sipsimple.account import MSRPSettings as AccountMSRPSettings, NATTraversalSettings as AccountNATTraversalSettings
from sipsimple.account import RTPSettings as AccountRTPSettings, SIPSettings as AccountSIPSettings, TLSSettings as AccountTLSSettings, SRTPEncryptionSettings as AccountSRTPEncryptionSettings
from sipsimple.account import MessageSummarySettings as AccountMessageSummarySettings, PresenceSettings as AccountPresenceSettingss, XCAPSettings as AccountXCAPSettings
from sipsimple.configuration import CorrelatedSetting, Setting, SettingsObjectExtension
from sipsimple.configuration.datatypes import MSRPConnectionModel, MSRPTransport, NonNegativeInteger, PortRange, SampleRate, SIPTransportList, SRTPKeyNegotiation
from sipsimple.configuration.settings import AudioSettings, EchoCancellerSettings, FileTransferSettings, LogsSettings, RTPSettings, SIPSettings, TLSSettings
from sylk import __version__ as server_version
from sylk.configuration import ServerConfig, SIPConfig, MSRPConfig, RTPConfig
from sylk.configuration.datatypes import AudioCodecs, Path, Port, SIPProxyAddress
# Account settings extensions
class AccountMessageSummarySettingsExtension(AccountMessageSummarySettings):
enabled = Setting(type=bool, default=False)
class AccountMSRPSettingsExtension(AccountMSRPSettings):
transport = Setting(type=MSRPTransport, default='tls' if MSRPConfig.use_tls else 'tcp')
connection_model = Setting(type=MSRPConnectionModel, default='relay' if ServerConfig.enable_bonjour else 'acm')
class AccountNATTraversalSettingsExtension(AccountNATTraversalSettings):
use_ice = Setting(type=bool, default=SIPConfig.enable_ice)
use_msrp_relay_for_outbound = Setting(type=bool, default=False)
class AccountPresenceSettingssExtension(AccountPresenceSettingss):
enabled = Setting(type=bool, default=False)
if RTPConfig.srtp_encryption == 'disabled':
# doesn't matter because it's disabled
srtp_key_negotiation = 'opportunistic'
elif RTPConfig.srtp_encryption == 'sdes':
srtp_key_negotiation = 'sdes_optional'
else:
srtp_key_negotiation = RTPConfig.srtp_encryption
class AccountSRTPEncryptionSettingsExtension(AccountSRTPEncryptionSettings):
enabled = Setting(type=bool, default=RTPConfig.srtp_encryption!='disabled')
key_negotiation = Setting(type=SRTPKeyNegotiation, default=srtp_key_negotiation)
class AccountRTPSettingsExtension(AccountRTPSettings):
audio_codec_list = Setting(type=AudioCodecs, default=None, nillable=True)
encryption = AccountSRTPEncryptionSettingsExtension
class AccountSIPSettingsExtension(AccountSIPSettings):
register = Setting(type=bool, default=False)
outbound_proxy = Setting(type=SIPProxyAddress, default=SIPConfig.outbound_proxy, nillable=True)
account_cert = ServerConfig.certificate
if account_cert is not None and not os.path.isfile(account_cert):
account_cert = None
class AccountTLSSettingsExtension(AccountTLSSettings):
certificate = Setting(type=Path, default=account_cert, nillable=True)
verify_server = Setting(type=bool, default=ServerConfig.verify_server)
class AccountXCAPSettingsExtension(AccountXCAPSettings):
enabled = Setting(type=bool, default=False)
class AccountExtension(SettingsObjectExtension):
enabled = Setting(type=bool, default=True)
message_summary = AccountMessageSummarySettingsExtension
msrp = AccountMSRPSettingsExtension
nat_traversal = AccountNATTraversalSettingsExtension
presence = AccountPresenceSettingssExtension
rtp = AccountRTPSettingsExtension
sip = AccountSIPSettingsExtension
tls = AccountTLSSettingsExtension
xcap = AccountXCAPSettingsExtension
class BonjourAccountExtension(SettingsObjectExtension):
enabled = Setting(type=bool, default=False)
# General settings extensions
class EchoCancellerSettingsExtension(EchoCancellerSettings):
enabled = Setting(type=bool, default=False)
tail_length = Setting(type=NonNegativeInteger, default=0)
class AudioSettingsExtension(AudioSettings):
input_device = Setting(type=str, default=None, nillable=True)
output_device = Setting(type=str, default=None, nillable=True)
sample_rate = Setting(type=SampleRate, default=RTPConfig.sample_rate)
echo_canceller = EchoCancellerSettings
class FileTransferSettingsExtension(FileTransferSettings):
directory = Setting(type=Path, default=Path(os.path.join(ServerConfig.spool_dir.normalized, 'file_transfers')))
class LogsSettingsExtension(LogsSettings):
directory = Setting(type=Path, default=ServerConfig.trace_dir)
trace_sip = Setting(type=bool, default=ServerConfig.trace_sip)
trace_msrp = Setting(type=bool, default=ServerConfig.trace_msrp)
trace_pjsip = Setting(type=bool, default=ServerConfig.trace_core)
trace_notifications = Setting(type=bool, default=ServerConfig.trace_notifications)
class RTPSettingsExtension(RTPSettings):
audio_codec_list = Setting(type=AudioCodecs, default=RTPConfig.audio_codecs)
port_range = Setting(type=PortRange, default=PortRange(RTPConfig.port_range.start, RTPConfig.port_range.end))
timeout = Setting(type=NonNegativeInteger, default=RTPConfig.timeout)
ca_file = ServerConfig.ca_file
if ca_file is not None and not os.path.isfile(ca_file):
ca_file = None
class TLSSettingsExtension(TLSSettings):
ca_list = Setting(type=Path, default=ca_file, nillable=True)
def sip_port_validator(port, sibling_port):
if port == sibling_port != 0:
raise ValueError("the TCP and TLS ports must be different")
transport_list = []
if SIPConfig.local_udp_port is not None:
transport_list.append('udp')
if SIPConfig.local_tcp_port is not None:
transport_list.append('tcp')
tls_port = SIPConfig.local_tls_port
if tls_port is not None and None in (ca_file, account_cert):
log.warning('Cannot enable TLS because the CA or the certificate are not specified')
tls_port = None
if tls_port is not None:
transport_list.append('tls')
class SIPSettingsExtension(SIPSettings):
udp_port = Setting(type=Port, default=SIPConfig.local_udp_port, nillable=True)
tcp_port = CorrelatedSetting(type=Port, sibling='tls_port', validator=sip_port_validator, default=SIPConfig.local_tcp_port, nillable=True)
tls_port = CorrelatedSetting(type=Port, sibling='tcp_port', validator=sip_port_validator, default=tls_port, nillable=True)
transport_list = Setting(type=SIPTransportList, default=transport_list)
class SylkServerSettingsExtension(SettingsObjectExtension):
user_agent = Setting(type=str, default='SylkServer-%s' % server_version)
audio = AudioSettingsExtension
file_transfer = FileTransferSettingsExtension
logs = LogsSettingsExtension
rtp = RTPSettingsExtension
sip = SIPSettingsExtension
tls = TLSSettingsExtension
diff --git a/sylk/interfaces/__init__.py b/sylk/interfaces/__init__.py
index abdbbc0..e69de29 100644
--- a/sylk/interfaces/__init__.py
+++ b/sylk/interfaces/__init__.py
@@ -1,3 +0,0 @@
-# Copyright (C) 2011 AG Projects. See LICENSE for details.
-#
-
diff --git a/sylk/interfaces/sipthor.py b/sylk/interfaces/sipthor.py
index 02e1864..1b0d06e 100644
--- a/sylk/interfaces/sipthor.py
+++ b/sylk/interfaces/sipthor.py
@@ -1,113 +1,109 @@
-# Copyright (C) 2011 AG-Projects.
-#
-# This module is proprietary to AG Projects. Use of this module by third
-# parties is not supported.
__all__ = ['ConferenceNode']
from application import log
from application.notification import NotificationCenter, NotificationData
from application.python.types import Singleton
from eventlib.twistedutil import block_on, callInGreenThread
from gnutls.interfaces.twisted import X509Credentials
from gnutls.constants import COMP_DEFLATE, COMP_LZO, COMP_NULL
from twisted.internet import defer
from thor.eventservice import EventServiceClient, ThorEvent
from thor.entities import ThorEntitiesRoleMap, GenericThorEntity as ThorEntity
from thor.scheduler import KeepRunning
import sylk
from sylk.configuration import SIPConfig, ThorNodeConfig
class ConferenceNode(EventServiceClient):
__metaclass__ = Singleton
topics = ["Thor.Members"]
def __init__(self):
pass
def connectionLost(self, connector, reason):
"""Called when an event server connection goes away"""
self.connections.discard(connector.transport)
def connectionFailed(self, connector, reason):
"""Called when an event server connection has an unrecoverable error"""
connector.failed = True
available_connectors = set(c for c in self.connectors if not c.failed)
if not available_connectors:
NotificationCenter().post_notification('ThorNetworkGotFatalError', sender=self)
def start(self, roles):
# Needs to be called from a green thread
log.msg('Publishing %s roles to SIPThor' % roles)
self.node = ThorEntity(SIPConfig.local_ip.normalized, roles, version=sylk.__version__)
self.networks = {}
self.presence_message = ThorEvent('Thor.Presence', self.node.id)
self.shutdown_message = ThorEvent('Thor.Leave', self.node.id)
credentials = X509Credentials(ThorNodeConfig.certificate, ThorNodeConfig.private_key, [ThorNodeConfig.ca])
credentials.verify_peer = True
credentials.session_params.compressions = (COMP_LZO, COMP_DEFLATE, COMP_NULL)
EventServiceClient.__init__(self, ThorNodeConfig.domain, credentials)
def stop(self):
# Needs to be called from a green thread
self._shutdown()
def _monitor_event_servers(self):
def wrapped_func():
servers = self._get_event_servers()
self._update_event_servers(servers)
callInGreenThread(wrapped_func)
return KeepRunning
def _disconnect_all(self):
for conn in self.connectors:
conn.disconnect()
def _shutdown(self):
if self.disconnecting:
return
self.disconnecting = True
self.dns_monitor.cancel()
if self.advertiser:
self.advertiser.cancel()
if self.shutdown_message:
self._publish(self.shutdown_message)
requests = [conn.protocol.unsubscribe(*self.topics) for conn in self.connections]
d = defer.DeferredList([request.deferred for request in requests])
block_on(d)
self._disconnect_all()
def handle_event(self, event):
#print "Received event: %s" % event
networks = self.networks
role_map = ThorEntitiesRoleMap(event.message) # mapping between role names and lists of nodes with that role
updated = False
for role in self.node.roles + ('sip_proxy',):
try:
network = networks[role]
except KeyError:
from thor import network as thor_network
network = thor_network.new(ThorNodeConfig.multiply)
networks[role] = network
new_nodes = set([node.ip for node in role_map.get(role, [])])
old_nodes = set(network.nodes)
added_nodes = new_nodes - old_nodes
removed_nodes = old_nodes - new_nodes
if removed_nodes:
for node in removed_nodes:
network.remove_node(node)
plural = len(removed_nodes) != 1 and 's' or ''
log.msg("removed %s node%s: %s" % (role, plural, ', '.join(removed_nodes)))
updated = True
if added_nodes:
for node in added_nodes:
network.add_node(node)
plural = len(added_nodes) != 1 and 's' or ''
log.msg("added %s node%s: %s" % (role, plural, ', '.join(added_nodes)))
updated = True
if updated:
NotificationCenter().post_notification('ThorNetworkGotUpdate', sender=self, data=NotificationData(networks=self.networks))
diff --git a/sylk/log.py b/sylk/log.py
index dfb5ad2..9b222bb 100644
--- a/sylk/log.py
+++ b/sylk/log.py
@@ -1,297 +1,295 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
"""
Logging support adapted from SIP SIMPLE Client logger.
"""
__all__ = ["Logger"]
import datetime
import os
import sys
from pprint import pformat
from application import log
from application.notification import IObserver, NotificationCenter
from application.python import Null
from application.system import makedirs
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.threading import run_in_thread
from zope.interface import implements
class Logger(object):
implements(IObserver)
# public methods
#
def __init__(self):
self.stopped = False
self.msrp_level = log.level.ERROR
self._siptrace_filename = None
self._siptrace_file = None
self._siptrace_error = False
self._siptrace_start_time = None
self._siptrace_packet_count = 0
self._msrptrace_filename = None
self._msrptrace_file = None
self._msrptrace_error = False
self._pjsiptrace_filename = None
self._pjsiptrace_file = None
self._pjsiptrace_error = False
self._notifications_filename = None
self._notifications_file = None
self._notifications_error = False
self._log_directory_error = False
def start(self):
# try to create the log directory
try:
self._init_log_directory()
except Exception:
pass
# register to receive log notifications
NotificationCenter().add_observer(self)
self.stopped = False
def stop(self):
NotificationCenter().remove_observer(self)
self.stopped = False
self._close_files()
@run_in_thread('log-io')
def _close_files(self):
# close sip trace file
if self._siptrace_file is not None:
self._siptrace_file.close()
self._siptrace_file = None
# close msrp trace file
if self._msrptrace_file is not None:
self._msrptrace_file.close()
self._msrptrace_file = None
# close pjsip trace file
if self._pjsiptrace_file is not None:
self._pjsiptrace_file.close()
self._pjsiptrace_file = None
# close notifications trace file
if self._notifications_file is not None:
self._notifications_file.close()
self._notifications_file = None
def handle_notification(self, notification):
if self.stopped:
return
self._process_notification(notification)
@run_in_thread('log-io')
def _process_notification(self, notification):
settings = SIPSimpleSettings()
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
handler = getattr(self, '_LH_%s' % notification.name, Null)
handler(notification)
if notification.name not in ('SIPEngineLog', 'SIPEngineSIPTrace') and settings.logs.trace_notifications:
message = 'Notification name=%s sender=%s' % (notification.name, notification.sender)
if notification.data is not None:
message += '\n%s' % pformat(notification.data.__dict__)
if settings.logs.trace_notifications:
try:
self._init_log_file('notifications')
except Exception:
pass
else:
self._notifications_file.write('%s [%s %d]: %s\n' % (datetime.datetime.now(), os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._notifications_file.flush()
# notification handlers
#
def _NH_CFGSettingsObjectDidChange(self, notification):
settings = SIPSimpleSettings()
if notification.sender is settings:
if 'logs.directory' in notification.data.modified:
# sip trace
if self._siptrace_file is not None:
self._siptrace_file.close()
self._siptrace_file = None
# pjsip trace
if self._pjsiptrace_file is not None:
self._pjsiptrace_file.close()
self._pjsiptrace_file = None
# notifications trace
if self._notifications_file is not None:
self._notifications_file.close()
self._notifications_file = None
# try to create the log directory
try:
self._init_log_directory()
except Exception:
pass
# log handlers
#
def _LH_SIPEngineSIPTrace(self, notification):
settings = SIPSimpleSettings()
if not settings.logs.trace_sip:
return
if self._siptrace_start_time is None:
self._siptrace_start_time = notification.datetime
self._siptrace_packet_count += 1
if notification.data.received:
direction = "RECEIVED"
else:
direction = "SENDING"
buf = ["%s: Packet %d, +%s" % (direction, self._siptrace_packet_count, (notification.datetime - self._siptrace_start_time))]
buf.append("%(source_ip)s:%(source_port)d -(SIP over %(transport)s)-> %(destination_ip)s:%(destination_port)d" % notification.data.__dict__)
buf.append(notification.data.data)
buf.append('--')
message = '\n'.join(buf)
try:
self._init_log_file('siptrace')
except Exception:
pass
else:
self._siptrace_file.write('%s [%s %d]: %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._siptrace_file.flush()
def _LH_SIPEngineLog(self, notification):
settings = SIPSimpleSettings()
if not settings.logs.trace_pjsip:
return
message = "(%(level)d) %(message)s" % notification.data.__dict__
try:
self._init_log_file('pjsiptrace')
except Exception:
pass
else:
self._pjsiptrace_file.write('%s [%s %d] %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._pjsiptrace_file.flush()
def _LH_DNSLookupTrace(self, notification):
settings = SIPSimpleSettings()
if not settings.logs.trace_sip:
return
message = 'DNS lookup %(query_type)s %(query_name)s' % notification.data.__dict__
if notification.data.error is None:
message += ' succeeded, ttl=%d: ' % notification.data.answer.ttl
if notification.data.query_type == 'A':
message += ", ".join(record.address for record in notification.data.answer)
elif notification.data.query_type == 'SRV':
message += ", ".join('%d %d %d %s' % (record.priority, record.weight, record.port, record.target) for record in notification.data.answer)
elif notification.data.query_type == 'NAPTR':
message += ", ".join('%d %d "%s" "%s" "%s" %s' % (record.order, record.preference, record.flags, record.service, record.regexp, record.replacement) for record in notification.data.answer)
else:
import dns.resolver
message_map = {dns.resolver.NXDOMAIN: 'DNS record does not exist',
dns.resolver.NoAnswer: 'DNS response contains no answer',
dns.resolver.NoNameservers: 'no DNS name servers could be reached',
dns.resolver.Timeout: 'no DNS response received, the query has timed out'}
message += ' failed: %s' % message_map.get(notification.data.error.__class__, '')
try:
self._init_log_file('siptrace')
except Exception:
pass
else:
self._siptrace_file.write('%s [%s %d]: %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._siptrace_file.flush()
def _LH_MSRPTransportTrace(self, notification):
settings = SIPSimpleSettings()
if not settings.logs.trace_msrp:
return
arrow = {'incoming': '<--', 'outgoing': '-->'}[notification.data.direction]
local_address = notification.sender.getHost()
local_address = '%s:%d' % (local_address.host, local_address.port)
remote_address = notification.sender.getPeer()
remote_address = '%s:%d' % (remote_address.host, remote_address.port)
message = '%s %s %s\n' % (local_address, arrow, remote_address) + notification.data.data
try:
self._init_log_file('msrptrace')
except Exception:
pass
else:
self._msrptrace_file.write('%s [%s %d]: %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._msrptrace_file.flush()
def _LH_MSRPLibraryLog(self, notification):
settings = SIPSimpleSettings()
if not settings.logs.trace_msrp:
return
if notification.data.level < self.msrp_level:
return
message = '%s%s' % (notification.data.level.prefix, notification.data.message)
try:
self._init_log_file('msrptrace')
except Exception:
pass
else:
self._msrptrace_file.write('%s [%s %d]: %s\n' % (notification.datetime, os.path.basename(sys.argv[0]).rstrip('.py'), os.getpid(), message))
self._msrptrace_file.flush()
# private methods
#
def _init_log_directory(self):
settings = SIPSimpleSettings()
log_directory = settings.logs.directory.normalized
try:
makedirs(log_directory)
except Exception, e:
if not self._log_directory_error:
print "failed to create logs directory '%s': %s" % (log_directory, e)
self._log_directory_error = True
self._siptrace_error = True
self._pjsiptrace_error = True
self._notifications_error = True
raise
else:
self._log_directory_error = False
# sip trace
if self._siptrace_filename is None:
self._siptrace_filename = os.path.join(log_directory, 'sip_trace.log')
self._siptrace_error = False
# msrp trace
if self._msrptrace_filename is None:
self._msrptrace_filename = os.path.join(log_directory, 'msrp_trace.log')
self._msrptrace_error = False
# pjsip trace
if self._pjsiptrace_filename is None:
self._pjsiptrace_filename = os.path.join(log_directory, 'core_trace.log')
self._pjsiptrace_error = False
# notifications trace
if self._notifications_filename is None:
self._notifications_filename = os.path.join(log_directory, 'notifications_trace.log')
self._notifications_error = False
def _init_log_file(self, type):
if getattr(self, '_%s_file' % type) is None:
self._init_log_directory()
filename = getattr(self, '_%s_filename' % type)
try:
setattr(self, '_%s_file' % type, open(filename, 'a'))
except Exception, e:
if not getattr(self, '_%s_error' % type):
print "failed to create log file '%s': %s" % (filename, e)
setattr(self, '_%s_error' % type, True)
raise
else:
setattr(self, '_%s_error' % type, False)
diff --git a/sylk/resources.py b/sylk/resources.py
index c01b53b..6a5d7c4 100644
--- a/sylk/resources.py
+++ b/sylk/resources.py
@@ -1,52 +1,50 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details.
-#
import os
import sys
from application.python.descriptor import classproperty
class Resources(object):
"""Provide access to SylkServer's resources"""
_cached_directory = None
@classproperty
def directory(cls):
if cls._cached_directory is None:
binary_directory = os.path.dirname(os.path.realpath(sys.argv[0]))
if os.path.basename(binary_directory) == 'bin':
application_directory = os.path.dirname(binary_directory)
resources_component = 'share/sylkserver'
else:
application_directory = binary_directory
resources_component = 'resources'
cls._cached_directory = os.path.join(application_directory, resources_component).decode(sys.getfilesystemencoding())
return cls._cached_directory
@classmethod
def get(cls, resource):
return os.path.join(cls.directory, resource or u'')
class VarResources(object):
"""Provide access to SylkServer's resources that should go in /var"""
_cached_directory = None
@classproperty
def directory(cls):
if cls._cached_directory is None:
binary_directory = os.path.dirname(os.path.realpath(sys.argv[0]))
if os.path.basename(binary_directory) == 'bin':
path = '/var'
else:
path = 'var'
cls._cached_directory = os.path.abspath(path).decode(sys.getfilesystemencoding())
return cls._cached_directory
@classmethod
def get(cls, resource):
return os.path.join(cls.directory, resource or u'')
diff --git a/sylk/server.py b/sylk/server.py
index 2ee66ca..d4d2414 100644
--- a/sylk/server.py
+++ b/sylk/server.py
@@ -1,259 +1,257 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
import os
import sys
from threading import Event
from uuid import uuid4
from application import log
from application.notification import NotificationCenter
from application.python import Null
from application.system import makedirs
from eventlib import proc
from sipsimple.account import Account, BonjourAccount, AccountManager
from sipsimple.application import SIPApplication
from sipsimple.audio import AudioDevice, RootAudioBridge
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import AudioMixer
from sipsimple.lookup import DNSManager
from sipsimple.storage import MemoryStorage
from sipsimple.threading import ThreadManager
from sipsimple.threading.green import run_in_green_thread
from sipsimple.video import VideoDevice
from twisted.internet import reactor
# Load stream extensions needed for integration with SIP SIMPLE SDK
import sylk.streams
del sylk.streams
from sylk.accounts import DefaultAccount
from sylk.applications import IncomingRequestHandler
from sylk.configuration import ServerConfig, SIPConfig, ThorNodeConfig
from sylk.configuration.settings import AccountExtension, BonjourAccountExtension, SylkServerSettingsExtension
from sylk.log import Logger
from sylk.session import SessionManager
from sylk.web import WebServer
class SylkServer(SIPApplication):
def __init__(self):
self.request_handler = Null
self.thor_interface = Null
self.web_server = Null
self.logger = Logger()
self.stopping_event = Event()
self.stop_event = Event()
self.failed = False
def start(self, options):
self.options = options
if self.options.enable_bonjour:
ServerConfig.enable_bonjour = True
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self)
notification_center.add_observer(self, name='ThorNetworkGotFatalError')
Account.register_extension(AccountExtension)
BonjourAccount.register_extension(BonjourAccountExtension)
SIPSimpleSettings.register_extension(SylkServerSettingsExtension)
try:
super(SylkServer, self).start(MemoryStorage())
except Exception, e:
log.fatal("Error starting SIP Application: %s" % e)
sys.exit(1)
def _initialize_core(self):
# SylkServer needs to listen for extra events and request types
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
# initialize core
options = dict(# general
ip_address=SIPConfig.local_ip,
user_agent=settings.user_agent,
# SIP
detect_sip_loops=False,
udp_port=settings.sip.udp_port if 'udp' in settings.sip.transport_list else None,
tcp_port=settings.sip.tcp_port if 'tcp' in settings.sip.transport_list else None,
tls_port=None,
# TLS
tls_verify_server=False,
tls_ca_file=None,
tls_cert_file=None,
tls_privkey_file=None,
# rtp
rtp_port_range=(settings.rtp.port_range.start, settings.rtp.port_range.end),
# audio
codecs=list(settings.rtp.audio_codec_list),
# video
video_codecs=list(settings.rtp.video_codec_list),
enable_colorbar_device=True,
# logging
log_level=settings.logs.pjsip_level if settings.logs.trace_pjsip else 0,
trace_sip=settings.logs.trace_sip,
# events and requests to handle
events={'conference': ['application/conference-info+xml'],
'presence': ['application/pidf+xml'],
'refer': ['message/sipfrag;version=2.0']},
incoming_events=set(['conference', 'presence']),
incoming_requests=set(['MESSAGE']))
notification_center.add_observer(self, sender=self.engine)
self.engine.start(**options)
@run_in_green_thread
def _initialize_subsystems(self):
account_manager = AccountManager()
dns_manager = DNSManager()
notification_center = NotificationCenter()
session_manager = SessionManager()
settings = SIPSimpleSettings()
notification_center.post_notification('SIPApplicationWillStart', sender=self)
if self.state == 'stopping':
reactor.stop()
return
# Initialize default account
default_account = DefaultAccount()
account_manager.default_account = default_account
# initialize TLS
self._initialize_tls()
# initialize PJSIP internal resolver
self.engine.set_nameservers(dns_manager.nameservers)
# initialize audio objects
voice_mixer = AudioMixer(None, None, settings.audio.sample_rate, 0, 9999)
self.voice_audio_device = AudioDevice(voice_mixer)
self.voice_audio_bridge = RootAudioBridge(voice_mixer)
self.voice_audio_bridge.add(self.voice_audio_device)
# initialize video objects
self.video_device = VideoDevice(u'Colorbar generator', settings.video.resolution, settings.video.framerate)
# initialize instance id
settings.instance_id = uuid4().urn
settings.save()
# initialize ZRTP cache
makedirs(ServerConfig.spool_dir.normalized)
self.engine.zrtp_cache = os.path.join(ServerConfig.spool_dir.normalized, 'zrtp.db')
# initialize middleware components
dns_manager.start()
account_manager.start()
session_manager.start()
notification_center.add_observer(self, name='CFGSettingsObjectDidChange')
self.state = 'started'
notification_center.post_notification('SIPApplicationDidStart', sender=self)
# start SylkServer components
self.web_server = WebServer()
self.web_server.start()
self.request_handler = IncomingRequestHandler()
self.request_handler.start()
if ThorNodeConfig.enabled:
from sylk.interfaces.sipthor import ConferenceNode
self.thor_interface = ConferenceNode()
thor_roles = []
if 'conference' in self.request_handler.applications:
thor_roles.append('conference_server')
if 'xmppgateway' in self.request_handler.applications:
thor_roles.append('xmpp_gateway')
if 'webrtcgateway' in self.request_handler.applications:
thor_roles.append('webrtc_gateway')
self.thor_interface.start(thor_roles)
@run_in_green_thread
def _shutdown_subsystems(self):
dns_manager = DNSManager()
account_manager = AccountManager()
session_manager = SessionManager()
# terminate all sessions
p = proc.spawn(session_manager.stop)
p.wait()
# shutdown SylkServer components
procs = [proc.spawn(self.web_server.stop), proc.spawn(self.request_handler.stop), proc.spawn(self.thor_interface.stop)]
proc.waitall(procs)
# shutdown other middleware components
procs = [proc.spawn(dns_manager.stop), proc.spawn(account_manager.stop)]
proc.waitall(procs)
# shutdown engine
self.engine.stop()
self.engine.join()
# stop threads
thread_manager = ThreadManager()
thread_manager.stop()
# stop the reactor
reactor.stop()
def _NH_AudioDevicesDidChange(self, notification):
pass
def _NH_DefaultAudioDeviceDidChange(self, notification):
pass
def _NH_SIPApplicationFailedToStartTLS(self, notification):
log.fatal("Couldn't set TLS options: %s" % notification.data.error)
def _NH_SIPApplicationWillStart(self, notification):
self.logger.start()
settings = SIPSimpleSettings()
if settings.logs.trace_sip and self.logger._siptrace_filename is not None:
log.msg('Logging SIP trace to file "%s"' % self.logger._siptrace_filename)
if settings.logs.trace_msrp and self.logger._msrptrace_filename is not None:
log.msg('Logging MSRP trace to file "%s"' % self.logger._msrptrace_filename)
if settings.logs.trace_pjsip and self.logger._pjsiptrace_filename is not None:
log.msg('Logging PJSIP trace to file "%s"' % self.logger._pjsiptrace_filename)
if settings.logs.trace_notifications and self.logger._notifications_filename is not None:
log.msg('Logging notifications trace to file "%s"' % self.logger._notifications_filename)
def _NH_SIPApplicationDidStart(self, notification):
settings = SIPSimpleSettings()
local_ip = SIPConfig.local_ip
log.msg("SylkServer started, listening on:")
for transport in settings.sip.transport_list:
try:
log.msg("%s:%d (%s)" % (local_ip, getattr(self.engine, '%s_port' % transport), transport.upper()))
except TypeError:
pass
def _NH_SIPApplicationWillEnd(self, notification):
self.stopping_event.set()
def _NH_SIPApplicationDidEnd(self, notification):
log.msg('SIP application ended')
self.logger.stop()
if not self.stopping_event.is_set():
log.warning('SIP application ended without shutting down all subsystems')
self.stopping_event.set()
self.stop_event.set()
def _NH_SIPEngineGotException(self, notification):
log.error('An exception occured within the SIP core:\n%s\n' % notification.data.traceback)
self.failed = True
def _NH_SIPEngineDidFail(self, notification):
log.error('SIP engine failed')
self.failed = True
super(SylkServer, self)._NH_SIPEngineDidFail(notification)
def _NH_ThorNetworkGotFatalError(self, notification):
log.error("All Thor Event Servers have unrecoverable errors.")
diff --git a/sylk/session.py b/sylk/session.py
index 5add00f..b2de52c 100644
--- a/sylk/session.py
+++ b/sylk/session.py
@@ -1,1975 +1,1973 @@
-# Copyright (C) 2011 AG Projects. See LICENSE for details.
-#
import random
from threading import RLock
from time import time
from application.notification import IObserver, Notification, NotificationCenter, NotificationData
from application.python import Null, limit
from application.python.decorator import decorator, preserve_signature
from application.python.types import Singleton
from application.system import host
from eventlib import api, coros, proc
from sipsimple.account import AccountManager
from sipsimple.configuration.settings import SIPSimpleSettings
from sipsimple.core import Engine, Invitation, Subscription, SIPCoreError, SIPCoreInvalidStateError, PJSIPError, sip_status_messages
from sipsimple.core import ContactHeader, RouteHeader, FromHeader, ToHeader, ReasonHeader, WarningHeader
from sipsimple.core import SIPURI, SDPConnection, SDPSession, SDPMediaStream
from sipsimple.lookup import DNSLookup, DNSLookupError
from sipsimple.payloads import ParserError
from sipsimple.payloads.conference import ConferenceDocument
from sipsimple.streams import MediaStreamRegistry, InvalidStreamError, UnknownStreamError
from sipsimple.threading import run_in_twisted_thread
from sipsimple.threading.green import Command, run_in_green_thread
from sipsimple.util import ISOTimestamp
from twisted.internet import reactor
from zope.interface import implements
from sylk.accounts import DefaultAccount
from sylk.configuration import SIPConfig
class InvitationDisconnectedError(Exception):
def __init__(self, invitation, data):
self.invitation = invitation
self.data = data
class MediaStreamDidNotInitializeError(Exception):
def __init__(self, stream, data):
self.stream = stream
self.data = data
class MediaStreamDidFailError(Exception):
def __init__(self, stream, data):
self.stream = stream
self.data = data
class SubscriptionError(Exception):
def __init__(self, error, timeout, **attributes):
self.error = error
self.timeout = timeout
self.attributes = attributes
class SIPSubscriptionDidFail(Exception):
def __init__(self, data):
self.data = data
class InterruptSubscription(Exception):
pass
class TerminateSubscription(Exception):
pass
class IllegalStateError(RuntimeError):
pass
@decorator
def transition_state(required_state, new_state):
def state_transitioner(func):
@preserve_signature(func)
def wrapper(obj, *args, **kwargs):
with obj._lock:
if obj.state != required_state:
raise IllegalStateError('cannot call %s in %s state' % (func.__name__, obj.state))
obj.state = new_state
return func(obj, *args, **kwargs)
return wrapper
return state_transitioner
@decorator
def check_state(required_states):
def state_checker(func):
@preserve_signature(func)
def wrapper(obj, *args, **kwargs):
if obj.state not in required_states:
raise IllegalStateError('cannot call %s in %s state' % (func.__name__, obj.state))
return func(obj, *args, **kwargs)
return wrapper
return state_checker
class ConferenceHandler(object):
implements(IObserver)
def __init__(self, session):
self.session = session
self.active = False
self.subscribed = False
self._command_proc = None
self._command_channel = coros.queue()
self._data_channel = coros.queue()
self._subscription = None
self._subscription_proc = None
self._subscription_timer = None
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self.session)
notification_center.add_observer(self, name='NetworkConditionsDidChange')
self._command_proc = proc.spawn(self._run)
def _run(self):
while True:
command = self._command_channel.wait()
handler = getattr(self, '_CH_%s' % command.name)
handler(command)
def _activate(self):
self.active = True
command = Command('subscribe')
self._command_channel.send(command)
return command
def _deactivate(self):
self.active = False
command = Command('unsubscribe')
self._command_channel.send(command)
return command
def _resubscribe(self):
command = Command('subscribe')
self._command_channel.send(command)
return command
def _terminate(self):
notification_center = NotificationCenter()
notification_center.remove_observer(self, sender=self.session)
notification_center.remove_observer(self, name='NetworkConditionsDidChange')
self._deactivate()
command = Command('terminate')
self._command_channel.send(command)
command.wait()
self.session = None
def _CH_subscribe(self, command):
if self._subscription_timer is not None and self._subscription_timer.active():
self._subscription_timer.cancel()
self._subscription_timer = None
if self._subscription_proc is not None:
subscription_proc = self._subscription_proc
subscription_proc.kill(InterruptSubscription)
subscription_proc.wait()
self._subscription_proc = proc.spawn(self._subscription_handler, command)
def _CH_unsubscribe(self, command):
# Cancel any timer which would restart the subscription process
if self._subscription_timer is not None and self._subscription_timer.active():
self._subscription_timer.cancel()
self._subscription_timer = None
if self._subscription_proc is not None:
subscription_proc = self._subscription_proc
subscription_proc.kill(TerminateSubscription)
subscription_proc.wait()
self._subscription_proc = None
command.signal()
def _CH_terminate(self, command):
command.signal()
raise proc.ProcExit()
def _subscription_handler(self, command):
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
try:
# Lookup routes
account = self.session.account
if account.sip.outbound_proxy is not None:
uri = SIPURI(host=account.sip.outbound_proxy.host,
port=account.sip.outbound_proxy.port,
parameters={'transport': account.sip.outbound_proxy.transport})
elif account.sip.always_use_my_proxy:
uri = SIPURI(host=account.id.domain)
else:
uri = SIPURI.new(self.session.remote_identity.uri)
lookup = DNSLookup()
try:
routes = lookup.lookup_sip_proxy(uri, settings.sip.transport_list).wait()
except DNSLookupError, e:
timeout = random.uniform(15, 30)
raise SubscriptionError(error='DNS lookup failed: %s' % e, timeout=timeout)
target_uri = SIPURI.new(self.session.remote_identity.uri)
refresh_interval = getattr(command, 'refresh_interval', account.sip.subscribe_interval)
timeout = time() + 30
for route in routes:
remaining_time = timeout - time()
if remaining_time > 0:
try:
contact_uri = account.contact[route]
except KeyError:
continue
subscription = Subscription(target_uri,
FromHeader(SIPURI.new(self.session.local_identity.uri)),
ToHeader(target_uri),
ContactHeader(contact_uri),
'conference',
RouteHeader(route.uri),
credentials=account.credentials,
refresh=refresh_interval)
notification_center.add_observer(self, sender=subscription)
try:
subscription.subscribe(timeout=limit(remaining_time, min=1, max=5))
except SIPCoreError:
notification_center.remove_observer(self, sender=subscription)
timeout = 5
raise SubscriptionError(error='Internal error', timeout=timeout)
self._subscription = subscription
try:
while True:
notification = self._data_channel.wait()
if notification.sender is subscription and notification.name == 'SIPSubscriptionDidStart':
break
except SIPSubscriptionDidFail, e:
notification_center.remove_observer(self, sender=subscription)
self._subscription = None
if e.data.code == 407:
# Authentication failed, so retry the subscription in some time
timeout = random.uniform(60, 120)
raise SubscriptionError(error='Authentication failed', timeout=timeout)
elif e.data.code == 423:
# Get the value of the Min-Expires header
timeout = random.uniform(60, 120)
if e.data.min_expires is not None and e.data.min_expires > refresh_interval:
raise SubscriptionError(error='Interval too short', timeout=timeout, min_expires=e.data.min_expires)
else:
raise SubscriptionError(error='Interval too short', timeout=timeout)
elif e.data.code in (405, 406, 489, 1400):
command.signal(e)
return
else:
# Otherwise just try the next route
continue
else:
self.subscribed = True
command.signal()
break
else:
# There are no more routes to try, reschedule the subscription
timeout = random.uniform(60, 180)
raise SubscriptionError(error='No more routes to try', timeout=timeout)
# At this point it is subscribed. Handle notifications and ending/failures.
try:
while True:
notification = self._data_channel.wait()
if notification.sender is not self._subscription:
continue
if notification.name == 'SIPSubscriptionGotNotify':
if notification.data.event == 'conference' and notification.data.body:
try:
conference_info = ConferenceDocument.parse(notification.data.body)
except ParserError:
pass
else:
notification_center.post_notification('SIPSessionGotConferenceInfo', sender=self.session, data=NotificationData(conference_info=conference_info))
elif notification.name == 'SIPSubscriptionDidEnd':
break
except SIPSubscriptionDidFail:
self._command_channel.send(Command('subscribe'))
notification_center.remove_observer(self, sender=self._subscription)
except InterruptSubscription, e:
if not self.subscribed:
command.signal(e)
if self._subscription is not None:
notification_center.remove_observer(self, sender=self._subscription)
try:
self._subscription.end(timeout=2)
except SIPCoreError:
pass
except TerminateSubscription, e:
if not self.subscribed:
command.signal(e)
if self._subscription is not None:
try:
self._subscription.end(timeout=2)
except SIPCoreError:
pass
else:
try:
while True:
notification = self._data_channel.wait()
if notification.sender is self._subscription and notification.name == 'SIPSubscriptionDidEnd':
break
except SIPSubscriptionDidFail:
pass
finally:
notification_center.remove_observer(self, sender=self._subscription)
except SubscriptionError, e:
if 'min_expires' in e.attributes:
command = Command('subscribe', command.event, refresh_interval=e.attributes['min_expires'])
else:
command = Command('subscribe', command.event)
self._subscription_timer = reactor.callLater(e.timeout, self._command_channel.send, command)
finally:
self.subscribed = False
self._subscription = None
self._subscription_proc = None
@run_in_twisted_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPSubscriptionDidStart(self, notification):
self._data_channel.send(notification)
def _NH_SIPSubscriptionDidEnd(self, notification):
self._data_channel.send(notification)
def _NH_SIPSubscriptionDidFail(self, notification):
self._data_channel.send_exception(SIPSubscriptionDidFail(notification.data))
def _NH_SIPSubscriptionGotNotify(self, notification):
self._data_channel.send(notification)
def _NH_SIPSessionDidStart(self, notification):
if self.session.remote_focus:
self._activate()
@run_in_green_thread
def _NH_SIPSessionDidFail(self, notification):
self._terminate()
@run_in_green_thread
def _NH_SIPSessionDidEnd(self, notification):
self._terminate()
def _NH_SIPSessionDidRenegotiateStreams(self, notification):
if self.session.remote_focus and not self.active:
self._activate()
elif not self.session.remote_focus and self.active:
self._deactivate()
def _NH_NetworkConditionsDidChange(self, notification):
if self.active:
self._resubscribe()
class Session(object):
implements(IObserver)
media_stream_timeout = 15
short_reinvite_timeout = 5
def __init__(self, account):
self.account = account
self.direction = None
self.end_time = None
self.on_hold = False
self.proposed_streams = None
self.route = None
self.state = None
self.start_time = None
self.streams = None
self.transport = None
self.local_focus = False
self.remote_focus = False
self.greenlet = None
self.conference = None
self._channel = coros.queue()
self._hold_in_progress = False
self._invitation = None
self._local_identity = None
self._remote_identity = None
self._lock = RLock()
def init_incoming(self, invitation, data):
remote_sdp = invitation.sdp.proposed_remote
if not remote_sdp:
invitation.send_response(488)
return
self.proposed_streams = []
for index, media_stream in enumerate(remote_sdp.media):
if media_stream.port != 0:
for stream_type in MediaStreamRegistry:
try:
stream = stream_type.new_from_sdp(self, remote_sdp, index)
except InvalidStreamError:
break
except UnknownStreamError:
continue
else:
stream.index = index
self.proposed_streams.append(stream)
break
if not self.proposed_streams:
invitation.send_response(488)
return
self.direction = 'incoming'
self.state = 'incoming'
self.transport = invitation.transport
self._invitation = invitation
self.conference = ConferenceHandler(self)
if 'isfocus' in invitation.remote_contact_header.parameters:
self.remote_focus = True
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=invitation)
notification_center.post_notification('SIPSessionNewIncoming', self, NotificationData(streams=self.proposed_streams, headers=data.headers))
@transition_state(None, 'connecting')
@run_in_green_thread
def connect(self, from_header, to_header, route, streams, is_focus=False, contact_header=None, extra_headers=None):
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
connected = False
unhandled_notifications = []
extra_headers = extra_headers or []
if {'to', 'from', 'via', 'contact', 'route', 'record-route'}.intersection(header.name.lower() for header in extra_headers):
raise RuntimeError('invalid header in extra_headers: To, From, Via, Contact, Route and Record-Route headers are not allowed')
self.direction = 'outgoing'
self.proposed_streams = streams
self.route = route
self.transport = self.route.transport
self.local_focus = is_focus
self._invitation = Invitation()
self._local_identity = from_header
self._remote_identity = to_header
self.conference = ConferenceHandler(self)
notification_center.add_observer(self, sender=self._invitation)
notification_center.post_notification('SIPSessionNewOutgoing', self, NotificationData(streams=streams[:]))
for stream in self.proposed_streams:
notification_center.add_observer(self, sender=stream)
stream.initialize(self, direction='outgoing')
try:
wait_count = len(self.proposed_streams)
while wait_count > 0:
notification = self._channel.wait()
if notification.name == 'MediaStreamDidInitialize':
wait_count -= 1
if contact_header is None:
try:
contact_uri = self.account.contact[self.route]
except KeyError, e:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self._fail(originator='local', code=480, reason=sip_status_messages[480], error=str(e))
return
else:
contact_header = ContactHeader(contact_uri)
if SIPConfig.advertised_ip not in (None, '0.0.0.0'):
local_ip = SIPConfig.advertised_ip.normalized
elif SIPConfig.local_ip not in (None, '0.0.0.0'):
local_ip = SIPConfig.local_ip.normalized
else:
local_ip = contact_header.uri.host
connection = SDPConnection(local_ip)
local_sdp = SDPSession(local_ip, name=settings.user_agent)
for index, stream in enumerate(self.proposed_streams):
stream.index = index
media = stream.get_local_media(remote_sdp=None, index=index)
if media.connection is None or (media.connection is not None and not media.has_ice_attributes and not media.has_ice_candidates):
media.connection = connection
local_sdp.media.append(media)
route_header = RouteHeader(self.route.uri)
if is_focus:
contact_header.parameters['isfocus'] = None
self._invitation.send_invite(to_header.uri, from_header, to_header, route_header, contact_header, local_sdp, extra_headers=extra_headers)
try:
with api.timeout(settings.sip.invite_timeout):
while True:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
break
else:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self._fail(originator='remote', code=0, reason=None, error='SDP negotiation failed: %s' % notification.data.error)
return
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'early':
if notification.data.code == 180:
notification_center.post_notification('SIPSessionGotRingIndication', self, )
notification_center.post_notification('SIPSessionGotProvisionalResponse', self, NotificationData(code=notification.data.code, reason=notification.data.reason))
elif notification.data.state == 'connected':
if not connected:
connected = True
else:
unhandled_notifications.append(notification)
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
except api.TimeoutError:
self.end()
return
notification_center.post_notification('SIPSessionWillStart', self)
stream_map = dict((stream.index, stream) for stream in self.proposed_streams)
for index, local_media in enumerate(local_sdp.media):
remote_media = remote_sdp.media[index]
stream = stream_map[index]
if remote_media.port:
stream.start(local_sdp, remote_sdp, index)
else:
notification_center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
removed_streams = [stream for stream in self.proposed_streams if stream.index >= len(local_sdp.media)]
for stream in removed_streams:
notification_center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
invitation_notifications = []
with api.timeout(self.media_stream_timeout):
wait_count = len(self.proposed_streams)
while wait_count > 0:
notification = self._channel.wait()
if notification.name == 'MediaStreamDidStart':
wait_count -= 1
elif notification.name == 'SIPInvitationChangedState':
invitation_notifications.append(notification)
[self._channel.send(notification) for notification in invitation_notifications]
while not connected or self._channel:
notification = self._channel.wait()
if notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'early':
if notification.data.code == 180:
notification_center.post_notification('SIPSessionGotRingIndication', self)
notification_center.post_notification('SIPSessionGotProvisionalResponse', self, NotificationData(code=notification.data.code, reason=notification.data.reason))
elif notification.data.state == 'connected':
if not connected:
connected = True
else:
unhandled_notifications.append(notification)
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
except (MediaStreamDidNotInitializeError, MediaStreamDidFailError, api.TimeoutError), e:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
if isinstance(e, api.TimeoutError):
error = 'media stream timed out while starting'
elif isinstance(e, MediaStreamDidNotInitializeError):
error = 'media stream did not initialize: %s' % e.data.reason
else:
error = 'media stream failed: %s' % e.data.reason
self._fail(originator='local', code=0, reason=None, error=error)
except InvitationDisconnectedError, e:
notification_center.remove_observer(self, sender=self._invitation)
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self.state = 'terminated'
# As weird as it may sound, PJSIP accepts a BYE even without receiving a final response to the INVITE
if e.data.prev_state in ('connecting', 'connected') or getattr(e.data, 'method', None) == 'BYE':
notification_center.post_notification('SIPSessionWillEnd', self, NotificationData(originator=e.data.originator))
self.end_time = ISOTimestamp.now()
notification_center.post_notification('SIPSessionDidEnd', self, NotificationData(originator=e.data.originator, end_reason=e.data.disconnect_reason))
else:
if e.data.originator == 'remote':
code = e.data.code
reason = e.data.reason
elif e.data.disconnect_reason == 'timeout':
code = 408
reason = 'timeout'
elif e.data.originator == 'local' and e.data.code == 408:
code = e.data.code
reason = e.data.reason
else:
code = 0
reason = None
if e.data.originator == 'remote' and code // 100 == 3:
redirect_identities = e.data.headers.get('Contact', [])
else:
redirect_identities = None
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator=e.data.originator, code=code, reason=reason, failure_reason=e.data.disconnect_reason, redirect_identities=redirect_identities))
self.greenlet = None
except SIPCoreError, e:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self._fail(originator='local', code=0, reason=None, error='SIP core error: %s' % str(e))
else:
self.greenlet = None
self.state = 'connected'
self.streams = self.proposed_streams
self.proposed_streams = None
self.start_time = ISOTimestamp.now()
any_stream_ice = any(getattr(stream, 'ice_active', False) for stream in self.streams)
if any_stream_ice:
self._reinvite_after_ice()
notification_center.post_notification('SIPSessionDidStart', self, NotificationData(streams=self.streams[:]))
for notification in unhandled_notifications:
self.handle_notification(notification)
if self._hold_in_progress:
self._send_hold()
def _reinvite_after_ice(self):
# This function does not do any error checking, it's designed to be called at the end of connect and ad
self.state = 'sending_proposal'
self.greenlet = api.getcurrent()
local_sdp = SDPSession.new(self._invitation.sdp.active_local)
local_sdp.version += 1
for index, stream in enumerate(self.streams):
local_sdp.media[index] = stream.get_local_media(remote_sdp=None, index=index)
self._invitation.send_reinvite(sdp=local_sdp)
received_invitation_state = False
received_sdp_update = False
try:
with api.timeout(self.short_reinvite_timeout):
while not received_invitation_state or not received_sdp_update:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
received_sdp_update = True
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
for index, stream in enumerate(self.streams):
stream.update(local_sdp, remote_sdp, index)
else:
return
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
received_invitation_state = True
elif notification.data.state == 'disconnected':
self.end()
return
except Exception:
pass
finally:
self.state = 'connected'
self.greenlet = None
@check_state(['incoming', 'received_proposal'])
@run_in_green_thread
def send_ring_indication(self):
try:
self._invitation.send_response(180)
except SIPCoreInvalidStateError:
pass # The INVITE session might have already been cancelled; ignore the error
@transition_state('incoming', 'accepting')
@run_in_green_thread
def accept(self, streams, is_focus=False, extra_headers=None):
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
self.local_focus = is_focus
connected = False
unhandled_notifications = []
extra_headers = extra_headers or []
if {'to', 'from', 'via', 'contact', 'route', 'record-route'}.intersection(header.name.lower() for header in extra_headers):
raise RuntimeError('invalid header in extra_headers: To, From, Via, Contact, Route and Record-Route headers are not allowed')
for stream in self.proposed_streams:
if stream in streams:
notification_center.add_observer(self, sender=stream)
stream.initialize(self, direction='incoming')
self.proposed_streams = streams
try:
wait_count = len(self.proposed_streams)
while wait_count > 0:
notification = self._channel.wait()
if notification.name == 'MediaStreamDidInitialize':
wait_count -= 1
remote_sdp = self._invitation.sdp.proposed_remote
if SIPConfig.advertised_ip not in (None, '0.0.0.0'):
local_ip = SIPConfig.advertised_ip.normalized
elif SIPConfig.local_ip not in (None, '0.0.0.0'):
local_ip = SIPConfig.local_ip.normalized
else:
sdp_connection = remote_sdp.connection or next(media.connection for media in remote_sdp.media if media.connection is not None)
local_ip = host.outgoing_ip_for(sdp_connection.address) if sdp_connection.address != '0.0.0.0' else sdp_connection.address
if local_ip is None:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self._fail(originator='local', code=500, reason=sip_status_messages[500], error='could not get local IP address')
return
connection = SDPConnection(local_ip)
local_sdp = SDPSession(local_ip, name=settings.user_agent)
stream_map = dict((stream.index, stream) for stream in self.proposed_streams)
for index, media in enumerate(remote_sdp.media):
stream = stream_map.get(index, None)
if stream is not None:
media = stream.get_local_media(remote_sdp=remote_sdp, index=index)
if not media.has_ice_attributes and not media.has_ice_candidates:
media.connection = connection
else:
media = SDPMediaStream.new(media)
media.connection = connection
media.port = 0
media.attributes = []
media.bandwidth_info = []
local_sdp.media.append(media)
contact_header = ContactHeader.new(self._invitation.local_contact_header)
try:
local_contact_uri = self.account.contact[self._invitation.transport]
contact_header.uri = local_contact_uri
except KeyError:
pass
if is_focus:
contact_header.parameters['isfocus'] = None
self._invitation.send_response(200, contact_header=contact_header, sdp=local_sdp, extra_headers=extra_headers)
notification_center.post_notification('SIPSessionWillStart', sender=self)
# Local and remote SDPs will be set after the 200 OK is sent
while True:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
break
else:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self._fail(originator='remote', code=0, reason=None, error='SDP negotiation failed: %s' % notification.data.error)
return
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected':
if not connected:
connected = True
elif notification.data.prev_state == 'connected':
unhandled_notifications.append(notification)
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
wait_count = 0
stream_map = dict((stream.index, stream) for stream in self.proposed_streams)
for index, local_media in enumerate(local_sdp.media):
remote_media = remote_sdp.media[index]
stream = stream_map.get(index, None)
if stream is not None:
if remote_media.port:
wait_count += 1
stream.start(local_sdp, remote_sdp, index)
else:
notification_center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
removed_streams = [stream for stream in self.proposed_streams if stream.index >= len(local_sdp.media)]
for stream in removed_streams:
notification_center.remove_observer(self, sender=stream)
self.proposed_streams.remove(stream)
del stream_map[stream.index]
stream.deactivate()
stream.end()
with api.timeout(self.media_stream_timeout):
while wait_count > 0 or not connected or self._channel:
notification = self._channel.wait()
if notification.name == 'MediaStreamDidStart':
wait_count -= 1
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected':
if not connected:
connected = True
elif notification.data.prev_state == 'connected':
unhandled_notifications.append(notification)
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
else:
unhandled_notifications.append(notification)
except (MediaStreamDidNotInitializeError, MediaStreamDidFailError, api.TimeoutError), e:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
reason_header = None
if isinstance(e, api.TimeoutError):
if wait_count > 0:
error = 'media stream timed out while starting'
else:
error = 'No ACK received'
reason_header = ReasonHeader('SIP')
reason_header.cause = 500
reason_header.text = 'Missing ACK'
elif isinstance(e, MediaStreamDidNotInitializeError):
error = 'media stream did not initialize: %s' % e.data.reason
reason_header = ReasonHeader('SIP')
reason_header.cause = 500
reason_header.text = 'media stream did not initialize'
else:
error = 'media stream failed: %s' % e.data.reason
reason_header = ReasonHeader('SIP')
reason_header.cause = 500
reason_header.text = 'media stream failed to start'
self.start_time = ISOTimestamp.now()
if self._invitation.state in ('incoming', 'early'):
self._fail(originator='local', code=500, reason=sip_status_messages[500], error=error, reason_header=reason_header)
else:
self._fail(originator='local', code=0, reason=None, error=error, reason_header=reason_header)
except InvitationDisconnectedError, e:
notification_center.remove_observer(self, sender=self._invitation)
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self.state = 'terminated'
if e.data.prev_state in ('incoming', 'early'):
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='remote', code=487, reason='Session Cancelled', failure_reason=e.data.disconnect_reason, redirect_identities=None))
elif e.data.prev_state == 'connecting' and e.data.disconnect_reason == 'missing ACK':
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='local', code=200, reason=sip_status_messages[200], failure_reason=e.data.disconnect_reason, redirect_identities=None))
else:
notification_center.post_notification('SIPSessionWillEnd', self, NotificationData(originator='remote'))
self.end_time = ISOTimestamp.now()
notification_center.post_notification('SIPSessionDidEnd', self, NotificationData(originator='remote', end_reason=e.data.disconnect_reason))
self.greenlet = None
except SIPCoreInvalidStateError:
# the only reason for which this error can be thrown is if invitation.send_response was called after the INVITE session was cancelled by the remote party
notification_center.remove_observer(self, sender=self._invitation)
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self.greenlet = None
self.state = 'terminated'
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='remote', code=487, reason='Session Cancelled', failure_reason='user request', redirect_identities=None))
except SIPCoreError, e:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self._fail(originator='local', code=500, reason=sip_status_messages[500], error='SIP core error: %s' % str(e))
else:
self.greenlet = None
self.state = 'connected'
self.streams = self.proposed_streams
self.proposed_streams = None
self.start_time = ISOTimestamp.now()
notification_center.post_notification('SIPSessionDidStart', self, NotificationData(streams=self.streams[:]))
for notification in unhandled_notifications:
self.handle_notification(notification)
if self._hold_in_progress:
self._send_hold()
@transition_state('incoming', 'terminating')
@run_in_green_thread
def reject(self, code=603, reason=None):
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
try:
self._invitation.send_response(code, reason)
with api.timeout(1):
while True:
notification = self._channel.wait()
if notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'disconnected':
break
except SIPCoreInvalidStateError:
# the only reason for which this error can be thrown is if invitation.send_response was called after the INVITE session was cancelled by the remote party
notification_center.remove_observer(self, sender=self._invitation)
self.greenlet = None
self.state = 'terminated'
self.proposed_streams = None
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='remote', code=487, reason='Session Cancelled', failure_reason='user request', redirect_identities=None))
except SIPCoreError, e:
self._fail(originator='local', code=500, reason=sip_status_messages[500], error='SIP core error: %s' % str(e))
except api.TimeoutError:
notification_center.remove_observer(self, sender=self._invitation)
self.greenlet = None
self.state = 'terminated'
self.proposed_streams = None
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='local', code=code, reason=sip_status_messages[code], failure_reason='timeout', redirect_identities=None))
else:
notification_center.remove_observer(self, sender=self._invitation)
self.greenlet = None
self.state = 'terminated'
self.proposed_streams = None
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='local', code=code, reason=sip_status_messages[code], failure_reason='user request', redirect_identities=None))
@transition_state('received_proposal', 'accepting_proposal')
@run_in_green_thread
def accept_proposal(self, streams):
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
unhandled_notifications = []
streams = [stream for stream in streams if stream in self.proposed_streams]
for stream in streams:
notification_center.add_observer(self, sender=stream)
stream.initialize(self, direction='incoming')
try:
wait_count = len(streams)
while wait_count > 0:
notification = self._channel.wait()
if notification.name == 'MediaStreamDidInitialize':
wait_count -= 1
local_sdp = SDPSession.new(self._invitation.sdp.active_local)
local_sdp.version += 1
remote_sdp = self._invitation.sdp.proposed_remote
connection = SDPConnection(local_sdp.address)
stream_map = dict((stream.index, stream) for stream in streams)
for index, media in enumerate(remote_sdp.media):
stream = stream_map.get(index, None)
if stream is not None:
media = stream.get_local_media(remote_sdp=remote_sdp, index=index)
if not media.has_ice_attributes and not media.has_ice_candidates:
media.connection = connection
if index < len(local_sdp.media):
local_sdp.media[index] = media
else:
local_sdp.media.append(media)
elif index >= len(local_sdp.media): # actually == is sufficient
media = SDPMediaStream.new(media)
media.connection = connection
media.port = 0
media.attributes = []
media.bandwidth_info = []
local_sdp.media.append(media)
self._invitation.send_response(200, sdp=local_sdp)
prev_on_hold_streams = set(stream for stream in self.streams if stream.hold_supported and stream.on_hold_by_remote)
received_invitation_state = False
received_sdp_update = False
while not received_invitation_state or not received_sdp_update:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
received_sdp_update = True
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
for stream in self.streams:
stream.update(local_sdp, remote_sdp, stream.index)
else:
self._fail_proposal(originator='remote', error='SDP negotiation failed: %s' % notification.data.error)
return
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
received_invitation_state = True
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
on_hold_streams = set(stream for stream in self.streams if stream.hold_supported and stream.on_hold_by_remote)
if on_hold_streams != prev_on_hold_streams:
hold_supported_streams = (stream for stream in self.streams if stream.hold_supported)
notification_center.post_notification('SIPSessionDidChangeHoldState', self, NotificationData(originator='remote', on_hold=bool(on_hold_streams),
partial=bool(on_hold_streams) and any(not stream.on_hold_by_remote for stream in hold_supported_streams)))
for stream in streams:
# TODO: check if port is 0 in local_sdp. In that case PJSIP disabled the stream becuase it couldn't
# negotiation failed. If there are more streams, however, the negotiation is considered successful as a
# whole, so while we built a normal SDP, PJSIP modified it and sent it to the other side. That's kind io
# OK, but we cannot really start the stream. -Saul
stream.start(local_sdp, remote_sdp, stream.index)
with api.timeout(self.media_stream_timeout):
wait_count = len(streams)
while wait_count > 0 or self._channel:
notification = self._channel.wait()
if notification.name == 'MediaStreamDidStart':
wait_count -= 1
else:
unhandled_notifications.append(notification)
except (MediaStreamDidNotInitializeError, MediaStreamDidFailError, api.TimeoutError), e:
if isinstance(e, api.TimeoutError):
error = 'media stream timed out while starting'
elif isinstance(e, MediaStreamDidNotInitializeError):
error = 'media stream did not initialize: %s' % e.data.reason
else:
error = 'media stream failed: %s' % e.data.reason
self._fail_proposal(originator='remote', error=error)
except InvitationDisconnectedError, e:
self._fail_proposal(originator='remote', error='session ended')
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = notification_center
self.handle_notification(notification)
except SIPCoreError, e:
self._fail_proposal(originator='remote', error='SIP core error: %s' % str(e))
else:
self.greenlet = None
self.state = 'connected'
self.streams = self.streams + streams
proposed_streams = self.proposed_streams[:]
self.proposed_streams = None
notification_center.post_notification('SIPSessionProposalAccepted', self, NotificationData(originator='remote', accepted_streams=streams, proposed_streams=proposed_streams))
notification_center.post_notification('SIPSessionDidRenegotiateStreams', self, NotificationData(originator='remote', added_streams=streams, removed_streams=[]))
for notification in unhandled_notifications:
self.handle_notification(notification)
if self._hold_in_progress:
self._send_hold()
@transition_state('received_proposal', 'rejecting_proposal')
@run_in_green_thread
def reject_proposal(self, code=488, reason=None):
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
try:
self._invitation.send_response(code, reason)
with api.timeout(1, None):
while True:
notification = self._channel.wait()
if notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
break
except SIPCoreError, e:
self._fail_proposal(originator='remote', error='SIP core error: %s' % str(e))
else:
self.greenlet = None
self.state = 'connected'
proposed_streams = self.proposed_streams[:]
self.proposed_streams = None
notification_center.post_notification('SIPSessionProposalRejected', self, NotificationData(originator='remote', code=code, reason=sip_status_messages[code], proposed_streams=proposed_streams))
if self._hold_in_progress:
self._send_hold()
def add_stream(self, stream):
self.add_streams([stream])
@transition_state('connected', 'sending_proposal')
@run_in_green_thread
def add_streams(self, streams):
streams = list(set(streams).difference(self.streams))
if not streams:
self.state = 'connected'
return
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
settings = SIPSimpleSettings()
unhandled_notifications = []
self.proposed_streams = streams
for stream in self.proposed_streams:
notification_center.add_observer(self, sender=stream)
stream.initialize(self, direction='outgoing')
try:
wait_count = len(self.proposed_streams)
while wait_count > 0:
notification = self._channel.wait()
if notification.name == 'MediaStreamDidInitialize':
wait_count -= 1
elif notification.name == 'SIPInvitationChangedState':
# This is actually the only reason for which this notification could be received
if notification.data.state == 'connected' and notification.data.sub_state == 'received_proposal':
self._fail_proposal(originator='local', error='received stream proposal')
self.handle_notification(notification)
return
local_sdp = SDPSession.new(self._invitation.sdp.active_local)
local_sdp.version += 1
for stream in self.proposed_streams:
# Try to reuse a disabled media stream to avoid an ever-growing SDP
try:
index = next(index for index, media in enumerate(local_sdp.media) if media.port == 0)
reuse_media = True
except StopIteration:
index = len(local_sdp.media)
reuse_media = False
stream.index = index
media = stream.get_local_media(remote_sdp=None, index=index)
if reuse_media:
local_sdp.media[index] = media
else:
local_sdp.media.append(media)
self._invitation.send_reinvite(sdp=local_sdp)
notification_center.post_notification('SIPSessionNewProposal', sender=self, data=NotificationData(originator='local', proposed_streams=self.proposed_streams[:]))
received_invitation_state = False
received_sdp_update = False
try:
with api.timeout(settings.sip.invite_timeout):
while not received_invitation_state or not received_sdp_update:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
received_sdp_update = True
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
for s in self.streams:
s.update(local_sdp, remote_sdp, s.index)
else:
self._fail_proposal(originator='local', error='SDP negotiation failed: %s' % notification.data.error)
return
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
received_invitation_state = True
if notification.data.code >= 300:
for stream in self.proposed_streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self.greenlet = None
self.state = 'connected'
proposed_streams = self.proposed_streams[:]
self.proposed_streams = None
notification_center.post_notification('SIPSessionProposalRejected', self, NotificationData(originator='local', code=notification.data.code, reason=notification.data.reason, proposed_streams=proposed_streams))
return
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
except api.TimeoutError:
self.cancel_proposal()
return
accepted_streams = []
for stream in self.proposed_streams:
try:
remote_media = remote_sdp.media[stream.index]
except IndexError:
self._fail_proposal(originator='local', error='SDP media missing in answer')
return
else:
if remote_media.port:
stream.start(local_sdp, remote_sdp, stream.index)
accepted_streams.append(stream)
else:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
with api.timeout(self.media_stream_timeout):
wait_count = len(accepted_streams)
while wait_count > 0:
notification = self._channel.wait()
if notification.name == 'MediaStreamDidStart':
wait_count -= 1
except (MediaStreamDidFailError, api.TimeoutError), e:
if isinstance(e, api.TimeoutError):
error = 'media stream timed out while starting'
else:
error = 'media stream failed: %s' % e.data.reason
self._fail_proposal(originator='local', error=error)
except InvitationDisconnectedError, e:
self._fail_proposal(originator='local', error='session ended')
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = notification_center
self.handle_notification(notification)
except SIPCoreError, e:
self._fail_proposal(originator='local', error='SIP core error: %s' % str(e))
else:
self.greenlet = None
self.state = 'connected'
self.streams += accepted_streams
proposed_streams = self.proposed_streams
self.proposed_streams = None
any_stream_ice = any(getattr(stream, 'ice_active', False) for stream in accepted_streams)
if any_stream_ice:
self._reinvite_after_ice()
notification_center.post_notification('SIPSessionProposalAccepted', self, NotificationData(originator='local', accepted_streams=accepted_streams, proposed_streams=proposed_streams))
notification_center.post_notification('SIPSessionDidRenegotiateStreams', self, NotificationData(originator='local', added_streams=accepted_streams, removed_streams=[]))
for notification in unhandled_notifications:
self.handle_notification(notification)
if self._hold_in_progress:
self._send_hold()
def remove_stream(self, stream):
self.remove_streams([stream])
@transition_state('connected', 'sending_proposal')
@run_in_green_thread
def remove_streams(self, streams):
streams = list(set(streams).intersection(self.streams))
if not streams:
self.state = 'connected'
return
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
unhandled_notifications = []
try:
local_sdp = SDPSession.new(self._invitation.sdp.active_local)
local_sdp.version += 1
for stream in streams:
notification_center.remove_observer(self, sender=stream)
stream.deactivate()
self.streams.remove(stream)
media = local_sdp.media[stream.index]
media.port = 0
media.attributes = []
media.bandwidth_info = []
self._invitation.send_reinvite(sdp=local_sdp)
received_invitation_state = False
received_sdp_update = False
with api.timeout(self.short_reinvite_timeout):
while not received_invitation_state or not received_sdp_update:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
received_sdp_update = True
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
for s in self.streams:
s.update(local_sdp, remote_sdp, s.index)
else:
# TODO
pass
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
received_invitation_state = True
if not (200 <= notification.data.code < 300):
break
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
except InvitationDisconnectedError, e:
for stream in streams:
stream.end()
self.greenlet = None
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = notification_center
self.handle_notification(notification)
except (api.TimeoutError, MediaStreamDidFailError, SIPCoreError):
for stream in streams:
stream.end()
self.end()
else:
for stream in streams:
stream.end()
self.greenlet = None
self.state = 'connected'
notification_center.post_notification('SIPSessionDidRenegotiateStreams', self, NotificationData(originator='local', added_streams=[], removed_streams=streams))
for notification in unhandled_notifications:
self.handle_notification(notification)
if self._hold_in_progress:
self._send_hold()
@transition_state('sending_proposal', 'cancelling_proposal')
@run_in_green_thread
def cancel_proposal(self):
if self.greenlet is not None:
api.kill(self.greenlet, api.GreenletExit())
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
try:
self._invitation.cancel_reinvite()
while True:
try:
notification = self._channel.wait()
except MediaStreamDidFailError:
continue
if notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
if notification.data.code == 487:
proposed_streams = (self.proposed_streams or [])[:]
for stream in proposed_streams:
stream.deactivate()
stream.end()
self.state = 'connected'
self.proposed_streams = None
notification_center.post_notification('SIPSessionProposalRejected', self, NotificationData(originator='local', code=notification.data.code, reason=notification.data.reason, proposed_streams=proposed_streams))
elif notification.data.code == 200:
self.end()
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
break
except SIPCoreError, e:
proposed_streams = (self.proposed_streams or [])[:]
for stream in proposed_streams:
stream.deactivate()
stream.end()
self.greenlet = None
self.state = 'connected'
self.proposed_streams = None
notification_center.post_notification('SIPSessionProposalRejected', self, NotificationData(originator='local', code=0, reason='SIP core error: %s' % str(e), proposed_streams=proposed_streams))
except InvitationDisconnectedError, e:
self.proposed_streams = None
self.greenlet = None
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = notification_center
self.handle_notification(notification)
else:
self.proposed_streams = None
self.greenlet = None
self.state = 'connected'
finally:
if self._hold_in_progress:
self._send_hold()
@run_in_green_thread
def hold(self):
if self.on_hold or self._hold_in_progress:
return
self._hold_in_progress = True
streams = (self.streams or []) + (self.proposed_streams or [])
if not streams:
return
for stream in streams:
stream.hold()
if self.state == 'connected':
self._send_hold()
@run_in_green_thread
def unhold(self):
if not self.on_hold and not self._hold_in_progress:
return
self._hold_in_progress = False
streams = (self.streams or []) + (self.proposed_streams or [])
if not streams:
return
for stream in streams:
stream.unhold()
if self.state == 'connected':
self._send_unhold()
@run_in_green_thread
def end(self):
if self.state in (None, 'terminating', 'terminated'):
return
if self.greenlet is not None:
api.kill(self.greenlet, api.GreenletExit())
self.greenlet = None
notification_center = NotificationCenter()
if self._invitation is None or self._invitation.state is None:
# The invitation was not yet constructed
self.state = 'terminated'
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='local', code=487, reason='Session Cancelled', failure_reason='user request', redirect_identities=None))
return
invitation_state = self._invitation.state
if invitation_state in ('disconnecting', 'disconnected'):
return
self.greenlet = api.getcurrent()
self.state = 'terminating'
if invitation_state == 'connected':
notification_center.post_notification('SIPSessionWillEnd', self, NotificationData(originator='local'))
streams = (self.streams or []) + (self.proposed_streams or [])
for stream in streams[:]:
try:
notification_center.remove_observer(self, sender=stream)
except KeyError:
streams.remove(stream)
else:
stream.deactivate()
cancelling = invitation_state != 'connected' and self.direction == 'outgoing'
try:
self._invitation.end(timeout=1)
while True:
try:
notification = self._channel.wait()
except MediaStreamDidFailError:
continue
if notification.name == 'SIPInvitationChangedState' and notification.data.state == 'disconnected':
break
except SIPCoreError, e:
if cancelling:
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='local', code=0, reason=None, failure_reason='SIP core error: %s' % str(e), redirect_identities=None))
else:
self.end_time = ISOTimestamp.now()
notification_center.post_notification('SIPSessionDidEnd', self, NotificationData(originator='local', end_reason='SIP core error: %s' % str(e)))
except InvitationDisconnectedError, e:
# As it weird as it may sound, PJSIP accepts a BYE even without receiving a final response to the INVITE
if e.data.prev_state == 'connected':
self.end_time = ISOTimestamp.now()
notification_center.post_notification('SIPSessionDidEnd', self, NotificationData(originator=e.data.originator, end_reason=e.data.disconnect_reason))
elif getattr(e.data, 'method', None) == 'BYE' and e.data.originator == 'remote':
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator=e.data.originator, code=0, reason=None, failure_reason=e.data.disconnect_reason, redirect_identities=None))
else:
if e.data.originator == 'remote':
code = e.data.code
reason = e.data.reason
elif e.data.disconnect_reason == 'timeout':
code = 408
reason = 'timeout'
else:
code = 0
reason = None
if e.data.originator == 'remote' and code // 100 == 3:
redirect_identities = e.data.headers.get('Contact', [])
else:
redirect_identities = None
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator=e.data.originator, code=code, reason=reason, failure_reason=e.data.disconnect_reason, redirect_identities=redirect_identities))
else:
if cancelling:
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator='local', code=487, reason='Session Cancelled', failure_reason='user request', redirect_identities=None))
else:
self.end_time = ISOTimestamp.now()
notification_center.post_notification('SIPSessionDidEnd', self, NotificationData(originator='local', end_reason='user request'))
finally:
for stream in streams:
stream.end()
notification_center.remove_observer(self, sender=self._invitation)
self.greenlet = None
self.state = 'terminated'
@property
def local_identity(self):
if self._invitation is not None and self._invitation.local_identity is not None:
return self._invitation.local_identity
else:
return self._local_identity
@property
def peer_address(self):
return self._invitation.peer_address if self._invitation is not None else None
@property
def remote_identity(self):
if self._invitation is not None and self._invitation.remote_identity is not None:
return self._invitation.remote_identity
else:
return self._remote_identity
@property
def remote_user_agent(self):
return self._invitation.remote_user_agent if self._invitation is not None else None
@property
def call_id(self):
return self._invitation.call_id if self._invitation is not None else None
@property
def request_uri(self):
return self._invitation.request_uri if self._invitation is not None else None
def _cancel_hold(self):
notification_center = NotificationCenter()
try:
self._invitation.cancel_reinvite()
while True:
try:
notification = self._channel.wait()
except MediaStreamDidFailError:
continue
if notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
if notification.data.code == 200:
self.end()
return False
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
break
except SIPCoreError:
pass
except InvitationDisconnectedError, e:
self.greenlet = None
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = notification_center
self.handle_notification(notification)
return False
return True
def _send_hold(self):
self.state = 'sending_proposal'
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
unhandled_notifications = []
try:
local_sdp = SDPSession.new(self._invitation.sdp.active_local)
local_sdp.version += 1
for stream in self.streams:
local_sdp.media[stream.index] = stream.get_local_media(remote_sdp=None, index=stream.index)
self._invitation.send_reinvite(sdp=local_sdp)
received_invitation_state = False
received_sdp_update = False
with api.timeout(self.short_reinvite_timeout):
while not received_invitation_state or not received_sdp_update:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
received_sdp_update = True
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
for stream in self.streams:
stream.update(local_sdp, remote_sdp, stream.index)
else:
# TODO
pass
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
received_invitation_state = True
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
except InvitationDisconnectedError, e:
self.greenlet = None
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = notification_center
self.handle_notification(notification)
return
except api.TimeoutError:
if not self._cancel_hold():
return
except SIPCoreError:
pass
self.greenlet = None
self.on_hold = True
self.state = 'connected'
hold_supported_streams = (stream for stream in self.streams if stream.hold_supported)
notification_center.post_notification('SIPSessionDidChangeHoldState', self, NotificationData(originator='local', on_hold=True, partial=any(not stream.on_hold_by_local for stream in hold_supported_streams)))
for notification in unhandled_notifications:
self.handle_notification(notification)
if self._hold_in_progress:
self._hold_in_progress = False
else:
for stream in self.streams:
stream.unhold()
self._send_unhold()
def _send_unhold(self):
self.state = 'sending_proposal'
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
unhandled_notifications = []
try:
local_sdp = SDPSession.new(self._invitation.sdp.active_local)
local_sdp.version += 1
for stream in self.streams:
local_sdp.media[stream.index] = stream.get_local_media(remote_sdp=None, index=stream.index)
self._invitation.send_reinvite(sdp=local_sdp)
received_invitation_state = False
received_sdp_update = False
with api.timeout(self.short_reinvite_timeout):
while not received_invitation_state or not received_sdp_update:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
received_sdp_update = True
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
for stream in self.streams:
stream.update(local_sdp, remote_sdp, stream.index)
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
received_invitation_state = True
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
except InvitationDisconnectedError, e:
self.greenlet = None
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = notification_center
self.handle_notification(notification)
return
except api.TimeoutError:
if not self._cancel_hold():
return
except SIPCoreError:
pass
self.greenlet = None
self.on_hold = False
self.state = 'connected'
notification_center.post_notification('SIPSessionDidChangeHoldState', self, NotificationData(originator='local', on_hold=False, partial=False))
for notification in unhandled_notifications:
self.handle_notification(notification)
if self._hold_in_progress:
for stream in self.streams:
stream.hold()
self._send_hold()
def _fail(self, originator, code, reason, error, reason_header=None):
notification_center = NotificationCenter()
prev_inv_state = self._invitation.state
self.state = 'terminating'
if prev_inv_state not in (None, 'incoming', 'outgoing', 'early', 'connecting'):
notification_center.post_notification('SIPSessionWillEnd', self, NotificationData(originator=originator))
if self._invitation.state not in (None, 'disconnecting', 'disconnected'):
try:
if self._invitation.direction == 'incoming' and self._invitation.state in ('incoming', 'early'):
if 400 <= code <= 699 and reason is not None:
self._invitation.send_response(code, extra_headers=[reason_header] if reason_header is not None else [])
else:
self._invitation.end(extra_headers=[reason_header] if reason_header is not None else [])
with api.timeout(1):
while True:
notification = self._channel.wait()
if notification.name == 'SIPInvitationChangedState' and notification.data.state == 'disconnected':
break
except (api.TimeoutError, SIPCoreError):
pass
notification_center.remove_observer(self, sender=self._invitation)
self.state = 'terminated'
notification_center.post_notification('SIPSessionDidFail', self, NotificationData(originator=originator, code=code, reason=reason, failure_reason=error, redirect_identities=None))
self.greenlet = None
def _fail_proposal(self, originator, error):
notification_center = NotificationCenter()
has_streams = bool(self.proposed_streams)
for stream in self.proposed_streams:
try:
notification_center.remove_observer(self, sender=stream)
except KeyError:
# _fail_proposal can be called from reject_proposal, which means the stream will
# not have been initialized or the session registered as an observer for it.
pass
else:
stream.deactivate()
stream.end()
if originator == 'remote' and self._invitation.sub_state == 'received_proposal':
try:
self._invitation.send_response(488 if has_streams else 500)
except SIPCoreError:
pass
notification_center.post_notification('SIPSessionHadProposalFailure', self, NotificationData(originator=originator, failure_reason=error, proposed_streams=self.proposed_streams[:]))
self.state = 'connected'
self.proposed_streams = None
self.greenlet = None
@run_in_green_thread
def handle_notification(self, notification):
handler = getattr(self, '_NH_%s' % notification.name, Null)
handler(notification)
def _NH_SIPInvitationChangedState(self, notification):
if self.state == 'terminated':
return
if notification.data.originator == 'remote' and notification.data.state not in ('disconnecting', 'disconnected'):
contact_header = notification.data.headers.get('Contact', None)
if contact_header and 'isfocus' in contact_header[0].parameters:
self.remote_focus = True
if self.greenlet is not None:
if notification.data.state == 'disconnected' and notification.data.prev_state != 'disconnecting':
self._channel.send_exception(InvitationDisconnectedError(notification.sender, notification.data))
else:
self._channel.send(notification)
else:
self.greenlet = api.getcurrent()
unhandled_notifications = []
try:
if notification.data.state == 'connected' and notification.data.sub_state == 'received_proposal':
self.state = 'received_proposal'
try:
proposed_remote_sdp = self._invitation.sdp.proposed_remote
active_remote_sdp = self._invitation.sdp.active_remote
if len(proposed_remote_sdp.media) < len(active_remote_sdp.media):
engine = Engine()
self._invitation.send_response(488, extra_headers=[WarningHeader(399, engine.user_agent, 'Streams cannot be deleted from the SDP')])
self.state = 'connected'
return
for stream in self.streams:
if not stream.validate_update(proposed_remote_sdp, stream.index):
engine = Engine()
self._invitation.send_response(488, extra_headers=[WarningHeader(399, engine.user_agent, 'Failed to update media stream index %d' % stream.index)])
self.state = 'connected'
return
added_media_indexes = set()
removed_media_indexes = set()
reused_media_indexes = set()
for index, media_stream in enumerate(proposed_remote_sdp.media):
if index >= len(active_remote_sdp.media):
added_media_indexes.add(index)
elif media_stream.port == 0 and active_remote_sdp.media[index].port > 0:
removed_media_indexes.add(index)
elif media_stream.port > 0 and active_remote_sdp.media[index].port == 0:
reused_media_indexes.add(index)
elif media_stream.media != active_remote_sdp.media[index].media:
added_media_indexes.add(index)
removed_media_indexes.add(index)
if added_media_indexes | reused_media_indexes and removed_media_indexes:
engine = Engine()
self._invitation.send_response(488, extra_headers=[WarningHeader(399, engine.user_agent, 'Both removing AND adding a media stream is currently not supported')])
self.state = 'connected'
return
elif added_media_indexes | reused_media_indexes:
self.proposed_streams = []
for index in added_media_indexes | reused_media_indexes:
media_stream = proposed_remote_sdp.media[index]
if media_stream.port != 0:
for stream_type in MediaStreamRegistry:
try:
stream = stream_type.new_from_sdp(self, proposed_remote_sdp, index)
except InvalidStreamError:
break
except UnknownStreamError:
continue
else:
stream.index = index
self.proposed_streams.append(stream)
break
if self.proposed_streams:
self._invitation.send_response(100)
notification.center.post_notification('SIPSessionNewProposal', sender=self, data=NotificationData(originator='remote', proposed_streams=self.proposed_streams[:]))
else:
self._invitation.send_response(488)
self.state = 'connected'
return
else:
local_sdp = SDPSession.new(self._invitation.sdp.active_local)
local_sdp.version += 1
removed_streams = [stream for stream in self.streams if stream.index in removed_media_indexes]
prev_on_hold_streams = set(stream for stream in self.streams if stream.hold_supported and stream.on_hold_by_remote)
for stream in removed_streams:
notification.center.remove_observer(self, sender=stream)
stream.deactivate()
media = local_sdp.media[stream.index]
media.port = 0
media.attributes = []
media.bandwidth_info = []
for stream in self.streams:
local_sdp.media[stream.index] = stream.get_local_media(remote_sdp=proposed_remote_sdp, index=stream.index)
try:
self._invitation.send_response(200, sdp=local_sdp)
except PJSIPError:
for stream in removed_streams:
self.streams.remove(stream)
stream.end()
if removed_streams:
self.end()
return
else:
try:
self._invitation.send_response(488)
except PJSIPError:
self.end()
return
else:
for stream in removed_streams:
self.streams.remove(stream)
stream.end()
received_invitation_state = False
received_sdp_update = False
while not received_sdp_update or not received_invitation_state or self._channel:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
received_sdp_update = True
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
for stream in self.streams:
stream.update(local_sdp, remote_sdp, stream.index)
else:
# TODO
pass
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
received_invitation_state = True
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
else:
unhandled_notifications.append(notification)
else:
unhandled_notifications.append(notification)
on_hold_streams = set(stream for stream in self.streams if stream.hold_supported and stream.on_hold_by_remote)
if on_hold_streams != prev_on_hold_streams:
hold_supported_streams = (stream for stream in self.streams if stream.hold_supported)
notification.center.post_notification('SIPSessionDidChangeHoldState', self, NotificationData(originator='remote', on_hold=bool(on_hold_streams),
partial=bool(on_hold_streams) and any(not stream.on_hold_by_remote for stream in hold_supported_streams)))
if removed_media_indexes:
notification.center.post_notification('SIPSessionDidRenegotiateStreams', self, NotificationData(originator='remote', added_streams=[], removed_streams=removed_streams))
except InvitationDisconnectedError, e:
self.greenlet = None
self.state == 'connected'
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = NotificationCenter()
self.handle_notification(notification)
except SIPCoreError:
self.end()
else:
self.state = 'connected'
elif notification.data.state == 'connected' and notification.data.sub_state == 'received_proposal_request':
self.state = 'received_proposal_request'
try:
# An empty proposal was received, generate an offer
self._invitation.send_response(100)
local_sdp = SDPSession.new(self._invitation.sdp.active_local)
local_sdp.version += 1
connection_address = host.outgoing_ip_for(self._invitation.peer_address.ip)
if local_sdp.connection is not None:
local_sdp.connection.address = connection_address
for index, stream in enumerate(self.streams):
stream.reset(index)
media = stream.get_local_media(remote_sdp=None, index=index)
if media.connection is not None:
media.connection.address = connection_address
local_sdp.media[stream.index] = media
self._invitation.send_response(200, sdp=local_sdp)
received_invitation_state = False
received_sdp_update = False
while not received_sdp_update or not received_invitation_state or self._channel:
notification = self._channel.wait()
if notification.name == 'SIPInvitationGotSDPUpdate':
received_sdp_update = True
if notification.data.succeeded:
local_sdp = notification.data.local_sdp
remote_sdp = notification.data.remote_sdp
for stream in self.streams:
stream.update(local_sdp, remote_sdp, stream.index)
else:
# TODO
pass
elif notification.name == 'SIPInvitationChangedState':
if notification.data.state == 'connected' and notification.data.sub_state == 'normal':
received_invitation_state = True
elif notification.data.state == 'disconnected':
raise InvitationDisconnectedError(notification.sender, notification.data)
else:
unhandled_notifications.append(notification)
else:
unhandled_notifications.append(notification)
except InvitationDisconnectedError, e:
self.greenlet = None
self.state == 'connected'
notification = Notification('SIPInvitationChangedState', e.invitation, e.data)
notification.center = NotificationCenter()
self.handle_notification(notification)
except SIPCoreError:
raise # FIXME
else:
self.state = 'connected'
elif notification.data.prev_state == notification.data.state == 'connected' and notification.data.prev_sub_state == 'received_proposal' and notification.data.sub_state == 'normal':
if notification.data.originator == 'local' and notification.data.code == 487:
self.state = 'connected'
proposed_streams = self.proposed_streams[:]
self.proposed_streams = None
notification.center.post_notification('SIPSessionProposalRejected', self, NotificationData(originator='remote', code=notification.data.code, reason=notification.data.reason, proposed_streams=proposed_streams))
if self._hold_in_progress:
self._send_hold()
elif notification.data.state == 'disconnected':
if self.state == 'incoming':
self.state = 'terminated'
if notification.data.originator == 'remote':
notification.center.post_notification('SIPSessionDidFail', self, NotificationData(originator='remote', code=487, reason='Session Cancelled', failure_reason=notification.data.disconnect_reason, redirect_identities=None))
else:
# There must have been an error involved
notification.center.post_notification('SIPSessionDidFail', self, NotificationData(originator='local', code=0, reason=None, failure_reason=notification.data.disconnect_reason, redirect_identities=None))
else:
notification.center.post_notification('SIPSessionWillEnd', self, NotificationData(originator=notification.data.originator))
for stream in self.streams:
notification.center.remove_observer(self, sender=stream)
stream.deactivate()
stream.end()
self.state = 'terminated'
self.end_time = ISOTimestamp.now()
notification.center.post_notification('SIPSessionDidEnd', self, NotificationData(originator=notification.data.originator, end_reason=notification.data.disconnect_reason))
notification.center.remove_observer(self, sender=self._invitation)
finally:
self.greenlet = None
for notification in unhandled_notifications:
self.handle_notification(notification)
def _NH_SIPInvitationGotSDPUpdate(self, notification):
if self.greenlet is not None:
self._channel.send(notification)
def _NH_SIPInvitationTransferNewIncoming(self, notification):
self._invitation.notify_transfer_progress(500)
def _NH_RTPStreamDidEnableEncryption(self, notification):
if notification.sender.type != 'audio':
return
audio_stream = notification.sender
if audio_stream.encryption.type == 'ZRTP':
# start ZRTP on the video stream, if applicable
try:
video_stream = next(stream for stream in self.streams or [] if stream.type=='video')
except StopIteration:
return
if video_stream.encryption.type == 'ZRTP' and not video_stream.encryption.active:
video_stream.encryption.zrtp._enable(audio_stream)
def _NH_MediaStreamDidStart(self, notification):
stream = notification.sender
if stream.type == 'audio' and stream.encryption.type == 'ZRTP':
stream.encryption.zrtp._enable()
elif stream.type == 'video' and stream.encryption.type == 'ZRTP':
# start ZRTP on the video stream, if applicable
try:
audio_stream = next(stream for stream in self.streams or [] if stream.type=='audio')
except StopIteration:
pass
else:
if audio_stream.encryption.type == 'ZRTP' and audio_stream.encryption.active:
stream.encryption.zrtp._enable(audio_stream)
if self.greenlet is not None:
self._channel.send(notification)
def _NH_MediaStreamDidInitialize(self, notification):
if self.greenlet is not None:
self._channel.send(notification)
def _NH_MediaStreamDidNotInitialize(self, notification):
if self.greenlet is not None and self.state not in ('terminating', 'terminated'):
self._channel.send_exception(MediaStreamDidNotInitializeError(notification.sender, notification.data))
def _NH_MediaStreamDidFail(self, notification):
if self.greenlet is not None:
if self.state not in ('terminating', 'terminated'):
self._channel.send_exception(MediaStreamDidFailError(notification.sender, notification.data))
else:
stream = notification.sender
if self.streams == [stream]:
self.end()
else:
try:
self.remove_stream(stream)
except IllegalStateError:
self.end()
class SessionManager(object):
__metaclass__ = Singleton
implements(IObserver)
def __init__(self):
self.sessions = []
self.state = None
self._channel = coros.queue()
def start(self):
self.state = 'starting'
notification_center = NotificationCenter()
notification_center.post_notification('SIPSessionManagerWillStart', sender=self)
notification_center.add_observer(self, 'SIPInvitationChangedState')
notification_center.add_observer(self, 'SIPSessionNewIncoming')
notification_center.add_observer(self, 'SIPSessionNewOutgoing')
notification_center.add_observer(self, 'SIPSessionDidFail')
notification_center.add_observer(self, 'SIPSessionDidEnd')
self.state = 'started'
notification_center.post_notification('SIPSessionManagerDidStart', sender=self)
def stop(self):
self.state = 'stopping'
notification_center = NotificationCenter()
notification_center.post_notification('SIPSessionManagerWillEnd', sender=self)
for session in self.sessions:
session.end()
while self.sessions:
self._channel.wait()
notification_center.remove_observer(self, 'SIPInvitationChangedState')
notification_center.remove_observer(self, 'SIPSessionNewIncoming')
notification_center.remove_observer(self, 'SIPSessionNewOutgoing')
notification_center.remove_observer(self, 'SIPSessionDidFail')
notification_center.remove_observer(self, 'SIPSessionDidEnd')
self.state = 'stopped'
notification_center.post_notification('SIPSessionManagerDidEnd', sender=self)
@run_in_twisted_thread
def handle_notification(self, notification):
if notification.name == 'SIPInvitationChangedState' and notification.data.state == 'incoming':
account_manager = AccountManager()
account = account_manager.find_account(notification.data.request_uri)
if account is None:
account = DefaultAccount()
notification.sender.send_response(100)
session = Session(account)
session.init_incoming(notification.sender, notification.data)
elif notification.name in ('SIPSessionNewIncoming', 'SIPSessionNewOutgoing'):
self.sessions.append(notification.sender)
elif notification.name in ('SIPSessionDidFail', 'SIPSessionDidEnd'):
self.sessions.remove(notification.sender)
if self.state == 'stopping':
self._channel.send(notification)
diff --git a/sylk/streams.py b/sylk/streams.py
index 0e50b09..4369e4c 100644
--- a/sylk/streams.py
+++ b/sylk/streams.py
@@ -1,171 +1,169 @@
-# Copyright (C) 2010-2011 AG Projects. See LICENSE for details.
-#
from application.notification import NotificationCenter, NotificationData
from eventlib import api
from msrplib.connect import DirectConnector, DirectAcceptor
from msrplib.protocol import URI
from msrplib.session import contains_mime_type
from msrplib.transport import make_response
from sipsimple.core import SDPAttribute
from sipsimple.payloads.iscomposing import IsComposingDocument, State, LastActive, Refresh, ContentType
from sipsimple.streams.msrp import MSRPStreamBase as _MSRPStreamBase, MSRPStreamError, NotificationProxyLogger
from sipsimple.streams.msrp.chat import ChatStream as _ChatStream, Message, QueuedMessage, CPIMPayload, CPIMParserError
from sipsimple.threading.green import run_in_green_thread
from sipsimple.util import ISOTimestamp
from sylk.configuration import SIPConfig, ServerConfig
@run_in_green_thread
def MSRPStreamBase_initialize(self, session, direction):
self.greenlet = api.getcurrent()
notification_center = NotificationCenter()
notification_center.add_observer(self, sender=self)
try:
self.session = session
self.transport = self.session.account.msrp.transport
outgoing = direction=='outgoing'
logger = NotificationProxyLogger()
if self.session.account.msrp.connection_model == 'relay':
if not outgoing and self.remote_role in ('actpass', 'passive'):
# 'passive' not allowed by the RFC but play nice for interoperability. -Saul
self.msrp_connector = DirectConnector(logger=logger, use_sessmatch=True)
self.local_role = 'active'
elif not outgoing:
if self.transport=='tls' and None in (self.session.account.tls_credentials.cert, self.session.account.tls_credentials.key):
raise MSRPStreamError("Cannot accept MSRP connection without a TLS certificate")
self.msrp_connector = DirectAcceptor(logger=logger)
self.local_role = 'passive'
else:
# outgoing
self.msrp_connector = DirectConnector(logger=logger, use_sessmatch=True)
self.local_role = 'active'
else:
if not outgoing and self.remote_role in ('actpass', 'passive'):
# 'passive' not allowed by the RFC but play nice for interoperability. -Saul
self.msrp_connector = DirectConnector(logger=logger, use_sessmatch=True)
self.local_role = 'active'
else:
if not outgoing and self.transport=='tls' and None in (self.session.account.tls_credentials.cert, self.session.account.tls_credentials.key):
raise MSRPStreamError("Cannot accept MSRP connection without a TLS certificate")
self.msrp_connector = DirectAcceptor(logger=logger, use_sessmatch=True)
self.local_role = 'actpass' if outgoing else 'passive'
full_local_path = self.msrp_connector.prepare(local_uri=URI(host=SIPConfig.local_ip.normalized, port=0, use_tls=self.transport=='tls', credentials=self.session.account.tls_credentials))
self.local_media = self._create_local_media(full_local_path)
except Exception, e:
notification_center.post_notification('MediaStreamDidNotInitialize', self, NotificationData(reason=str(e)))
else:
self._initialized = True
notification_center.post_notification('MediaStreamDidInitialize', self)
finally:
self.greenlet = None
# Monkey-patch the initialize method
_MSRPStreamBase.initialize = MSRPStreamBase_initialize
class ChatStream(_ChatStream):
priority = _ChatStream.priority + 1
accept_types = ['message/cpim']
accept_wrapped_types = ['*']
chatroom_capabilities = ['nickname', 'private-messages', 'com.ag-projects.screen-sharing', 'com.ag-projects.zrtp-sas']
@property
def private_messages_allowed(self):
# As a server, we always support sending private messages
return True
def _create_local_media(self, uri_path):
local_media = super(ChatStream, self)._create_local_media(uri_path)
if self.session.local_focus and self.chatroom_capabilities:
caps = self.chatroom_capabilities[:]
if ServerConfig.enable_bonjour:
caps.remove('private-messages')
local_media.attributes.append(SDPAttribute('chatroom', ' '.join(caps)))
return local_media
def _handle_SEND(self, chunk):
# This ChatStream doesn't send MSRP REPORT chunks automatically, the developer needs to manually send them
if chunk.size == 0:
# keep-alive
self.msrp_session.send_report(chunk, 200, 'OK')
return
if self.direction=='sendonly':
self.msrp_session.send_report(chunk, 413, 'Unwanted Message')
return
if chunk.content_type.lower() != 'message/cpim':
self.incoming_queue.pop(chunk.message_id, None)
self.msrp_session.send_report(chunk, 415, 'Invalid Content-Type')
return
if chunk.contflag == '#':
self.incoming_queue.pop(chunk.message_id, None)
self.msrp_session.send_report(chunk, 200, 'OK')
return
elif chunk.contflag == '+':
self.incoming_queue[chunk.message_id].append(chunk.data)
self.msrp_session.send_report(chunk, 200, 'OK')
return
else:
data = ''.join(self.incoming_queue.pop(chunk.message_id, [])) + chunk.data
try:
payload = CPIMPayload.decode(data)
except CPIMParserError:
self.msrp_session.send_report(chunk, 400, 'CPIM Parser Error')
return
message = Message(**payload.__dict__)
if not contains_mime_type(self.accept_wrapped_types, message.content_type):
self.msrp_session.send_report(chunk, 415, 'Invalid Content-Type')
return
if message.timestamp is None:
message.timestamp = ISOTimestamp.now()
if message.sender is None:
message.sender = self.remote_identity
private = self.session.remote_focus and len(message.recipients) == 1 and message.recipients[0] != self.remote_identity
notification_center = NotificationCenter()
if message.content_type.lower() == IsComposingDocument.content_type:
data = IsComposingDocument.parse(message.content)
ndata = NotificationData(state=data.state.value,
refresh=data.refresh.value if data.refresh is not None else 120,
content_type=data.content_type.value if data.content_type is not None else None,
last_active=data.last_active.value if data.last_active is not None else None,
sender=message.sender, recipients=message.recipients, private=private, chunk=chunk)
notification_center.post_notification('ChatStreamGotComposingIndication', self, ndata)
else:
notification_center.post_notification('ChatStreamGotMessage', self, NotificationData(message=message, private=private, chunk=chunk))
def _handle_NICKNAME(self, chunk):
nickname = chunk.headers['Use-Nickname'].decoded
NotificationCenter().post_notification('ChatStreamGotNicknameRequest', self, NotificationData(nickname=nickname, chunk=chunk))
@run_in_green_thread
def _send_nickname_response(self, response):
try:
self.msrp_session.send_chunk(response)
except Exception:
pass
def accept_nickname(self, chunk):
if chunk.method != 'NICKNAME':
raise ValueError('Incorrect chunk method for accept_nickname: %s' % chunk.method)
response = make_response(chunk, 200, 'OK')
self._send_nickname_response(response)
def reject_nickname(self, chunk, code, reason):
if chunk.method != 'NICKNAME':
raise ValueError('Incorrect chunk method for accept_nickname: %s' % chunk.method)
response = make_response(chunk, code, reason)
self._send_nickname_response(response)
def send_message(self, content, content_type='text/plain', sender=None, recipients=None, timestamp=None, additional_headers=None, message_id=None, notify_progress=True):
message = QueuedMessage(content, content_type, sender=sender, recipients=recipients, timestamp=timestamp, additional_headers=additional_headers, id=message_id, notify_progress=notify_progress)
self._enqueue_message(message)
return message.id
def send_composing_indication(self, state, refresh=None, last_active=None, sender=None, recipients=None, message_id=None, notify_progress=False):
content = IsComposingDocument.create(state=State(state), refresh=Refresh(refresh) if refresh is not None else None, last_active=LastActive(last_active) if last_active is not None else None, content_type=ContentType('text'))
message = QueuedMessage(content, IsComposingDocument.content_type, sender=sender, recipients=recipients, id=message_id, notify_progress=notify_progress)
self._enqueue_message(message)
return message.id
diff --git a/sylk/tls.py b/sylk/tls.py
index 6e06b73..213c778 100644
--- a/sylk/tls.py
+++ b/sylk/tls.py
@@ -1,52 +1,50 @@
-# Copyright (C) 2007-2011 AG Projects.
-#
"""TLS helper classes"""
__all__ = ['Certificate', 'PrivateKey']
from gnutls.crypto import X509Certificate, X509PrivateKey
from application import log
from application.process import process
def file_content(file):
path = process.config_file(file)
if path is None:
raise Exception("File '%s' does not exist" % file)
try:
f = open(path, 'rt')
except Exception:
raise Exception("File '%s' could not be open" % file)
try:
return f.read()
finally:
f.close()
class Certificate(object):
"""Configuration data type. Used to create a gnutls.crypto.X509Certificate object
from a file given in the configuration file."""
def __new__(typ, value):
if isinstance(value, basestring):
try:
return X509Certificate(file_content(value))
except Exception, e:
log.warn("Certificate file '%s' could not be loaded: %s" % (value, str(e)))
return None
else:
raise TypeError, 'value should be a string'
class PrivateKey(object):
"""Configuration data type. Used to create a gnutls.crypto.X509PrivateKey object
from a file given in the configuration file."""
def __new__(typ, value):
if isinstance(value, basestring):
try:
return X509PrivateKey(file_content(value))
except Exception, e:
log.warn("Private key file '%s' could not be loaded: %s" % (value, str(e)))
return None
else:
raise TypeError, 'value should be a string'
diff --git a/sylk/web/__init__.py b/sylk/web/__init__.py
index d30922e..c4815b5 100644
--- a/sylk/web/__init__.py
+++ b/sylk/web/__init__.py
@@ -1,83 +1,81 @@
-# Copyright (C) 2015 AG Projects. See LICENSE for details.
-#
__all__ = ['Klein', 'StaticFileResource', 'WebServer', 'server']
import os
from application import log
from application.python.types import Singleton
from twisted.internet import reactor
from twisted.internet.ssl import DefaultOpenSSLContextFactory
from twisted.web.resource import Resource, NoResource
from twisted.web.server import Site
from twisted.web.static import File
from sylk import __version__
from sylk.configuration import WebServerConfig
from sylk.web.klein import Klein
# Set the 'Server' header string which Twisted Web will use
import twisted.web.server
twisted.web.server.version = b'SylkServer/%s' % __version__
class StaticFileResource(File):
def directoryListing(self):
return NoResource('Directory listing not available')
class RootResource(Resource):
isLeaf = True
def render_GET(self, request):
request.setHeader('Content-Type', 'text/plain')
return 'Welcome to SylkServer!'
class WebServer(object):
__metaclass__ = Singleton
def __init__(self):
self.base = Resource()
self.base.putChild('', RootResource())
self.site = Site(self.base, logPath=os.devnull)
self.site.noisy = False
self.listener = None
@property
def url(self):
return self.__dict__.get('url', '')
def register_resource(self, path, resource):
self.base.putChild(path, resource)
def start(self):
interface = WebServerConfig.local_ip
port = WebServerConfig.local_port
cert_path = WebServerConfig.certificate.normalized if WebServerConfig.certificate else None
if cert_path is not None:
if not os.path.isfile(cert_path):
log.error('Certificate file %s could not be found' % cert_path)
return
try:
ssl_context = DefaultOpenSSLContextFactory(cert_path, cert_path)
except Exception:
log.exception('Creating SSL context')
log.err()
return
self.listener = reactor.listenSSL(port, self.site, ssl_context, backlog=511, interface=interface)
scheme = 'https'
else:
self.listener = reactor.listenTCP(port, self.site, backlog=511, interface=interface)
scheme = 'http'
port = self.listener.getHost().port
self.__dict__['url'] = '%s://%s:%d' % (scheme, WebServerConfig.hostname or interface.normalized, port)
log.msg('Web server listening for requests on: %s' % self.url)
def stop(self):
if self.listener is not None:
self.listener.stopListening()
server = WebServer()