pax_global_header00006660000000000000000000000064126461407470014525gustar00rootroot0000000000000052 comment=3a4184d1aba092629613e6de4b0f438ef1b63360 Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/000077500000000000000000000000001264614074700200555ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/.gitignore000066400000000000000000000001151264614074700220420ustar00rootroot00000000000000*~ *.pyc build dist .coverage .project .pydevproject .settings .tox MANIFEST Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/.pylintrc000066400000000000000000000152121264614074700217230ustar00rootroot00000000000000[MASTER] # Specify a configuration file. #rcfile= # Python code to execute, usually for sys.path manipulation such as # pygtk.require(). #init-hook= # Profiled execution. profile=no # Add to the black list. It should be a base name, not a # path. You may set this option multiple times. #ignore=CVS # Pickle collected data for later comparisons. persistent=yes # List of plugins (as comma separated values of python modules names) to load, # usually to register additional checkers. load-plugins= [MESSAGES CONTROL] # Enable the message, report, category or checker with the given id(s). You can # either give multiple identifier separated by comma (,) or put this option # multiple time. #enable= # Disable the message, report, category or checker with the given id(s). You # can either give multiple identifier separated by comma (,) or put this option # multiple time. # Remove warning removal warning # Remove stupid warning on ** magic # Remove stupid reimport warning disable=I0011,W0142,W0404 [REPORTS] # Set the output format. Available formats are text, parseable, colorized, msvs # (visual studio) and html #output-format=colorized # Include message's id in output #include-ids=yes # Put messages in a separate file for each module / package specified on the # command line instead of printing them on stdout. Reports (if any) will be # written in a file name "pylint_global.[txt|html]". #files-output=no # Tells whether to display a full report or only the messages #reports=no # Python expression which should return a note less than 10 (10 is the highest # note). You have access to the variables errors warning, statement which # respectively contain the number of errors / warnings messages and the total # number of statements analyzed. This is used by the global evaluation report # (R0004). evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) # Add a comment according to your evaluation note. This is used by the global # evaluation report (R0004). comment=no [TYPECHECK] # Tells whether missing members accessed in mixin class should be ignored. A # mixin class is detected if its name ends with "mixin" (case insensitive). ignore-mixin-members=yes # List of classes names for which member attributes should not be checked # (useful for classes with attributes dynamically set). ignored-classes=ParseResult,radicale.config,ldap # When zope mode is activated, add a predefined set of Zope acquired attributes # to generated-members. zope=no # List of members which are set dynamically and missed by pylint inference # system, and so shouldn't trigger E0201 when accessed. generated-members= [FORMAT] # Maximum number of characters on a single line. max-line-length=79 # Maximum number of lines in a module max-module-lines=1000 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 # tab). indent-string=' ' [VARIABLES] # Tells whether we should check for unused import in __init__ files. init-import=yes # A regular expression matching names used for dummy variables (i.e. not used). dummy-variables-rgx=_ # List of additional names supposed to be defined in builtins. Remember that # you should avoid to define new builtins when possible. additional-builtins= [MISCELLANEOUS] # List of note tags to take in consideration, separated by a comma. notes=FIXME,XXX,TODO [BASIC] # Required attributes for module, separated by a comma required-attributes= # List of builtins function names that should not be used, separated by a comma bad-functions=map,filter,apply,input # Regular expression which should only match correct module names module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ # Regular expression which should only match correct module level names const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$ # Regular expression which should only match correct class names class-rgx=[A-Z_][a-zA-Z0-9]+$ # Regular expression which should only match correct function names function-rgx=[a-z_][a-z0-9_]{2,30}$ # Regular expression which should only match correct method names method-rgx=[a-z_][a-z0-9_]{2,30}$ # Regular expression which should only match correct instance attribute names attr-rgx=[a-z_][a-z0-9_]{2,30}$ # Regular expression which should only match correct argument names argument-rgx=[a-z_][a-z0-9_]{2,30}$ # Regular expression which should only match correct variable names variable-rgx=[a-z_][a-z0-9_]{2,30}$ # Regular expression which should only match correct list comprehension / # generator expression variable names inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$ # Good variable names which should always be accepted, separated by a comma good-names=i,j,_ # Bad variable names which should always be refused, separated by a comma bad-names=foo,bar,baz,toto,tutu,tata # Regular expression which should only match functions or classes name which do # not require a docstring no-docstring-rgx=__.*__ [SIMILARITIES] # Minimum lines number of a similarity. min-similarity-lines=4 # Ignore comments when computing similarities. ignore-comments=yes # Ignore docstrings when computing similarities. ignore-docstrings=yes [CLASSES] # List of interface methods to ignore, separated by a comma. This is used for # instance to not check methods defines in Zope's Interface base class. ignore-iface-methods= # List of method names used to declare (i.e. assign) instance attributes. defining-attr-methods=__init__,__new__ [DESIGN] # Maximum number of arguments for function / method max-args=5 # Argument names that match this expression will be ignored. Default to name # with leading underscore ignored-argument-names=_.* # Maximum number of locals for function / method body max-locals=15 # Maximum number of return / yield for function / method body max-returns=6 # Maximum number of branch for function / method body max-branchs=12 # Maximum number of statements in function / method body max-statements=50 # Maximum number of parents for a class (see R0901). max-parents=7 # Maximum number of attributes for a class (see R0902). max-attributes=7 # Minimum number of public methods for a class (see R0903). min-public-methods=2 # Maximum number of public methods for a class (see R0904). max-public-methods=20 [IMPORTS] # Deprecated modules which should not be used, separated by a comma deprecated-modules=regsub,string,TERMIOS,Bastion,rexec # Create a graph of every (i.e. internal and external) dependencies in the # given file (report RP0402 must not be disabled) import-graph= # Create a graph of external dependencies in the given file (report RP0402 must # not be disabled) ext-import-graph= # Create a graph of internal dependencies in the given file (report RP0402 must # not be disabled) int-import-graph= Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/.travis.yml000066400000000000000000000003551264614074700221710ustar00rootroot00000000000000language: python python: - 2.6 - 2.7 - 3.2 - 3.3 - 3.4 - 3.5 install: - pip install sqlalchemy - pip install nose-cov - pip install pam - pip install requests - pip install dulwich script: nosetests sudo: false Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/COPYING000066400000000000000000001045131264614074700211140ustar00rootroot00000000000000 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. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/Dockerfile000066400000000000000000000015161264614074700220520ustar00rootroot00000000000000# Radicale Dockerfile # # VERSION 0.2 FROM debian:latest ENV DEBIAN_FRONTEND noninteractive # Base packages RUN apt-get update -qq && apt-get upgrade -y -qq RUN apt-get install -y --no-install-recommends git ca-certificates python2.7 python-setuptools python-pip \ build-essential libffi-dev python-dev # Radicale installation RUN pip install passlib bcrypt RUN mkdir -p /data/config && \ cd /data COPY . /data/radicale COPY config /data/config RUN cd /data/radicale && python2.7 setup.py install # User RUN useradd -d /home/radicale -m radicale && \ mkdir -p /home/radicale/.config && \ ln -s /data/config /home/radicale/.config/radicale && \ chown -R radicale:radicale /data/config && \ chown -R radicale:radicale /home/radicale USER radicale WORKDIR /home/radicale CMD ["radicale", "-D", "-C", "/data/config/config"] Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/MANIFEST.in000066400000000000000000000001571264614074700216160ustar00rootroot00000000000000include COPYING NEWS.rst TODO.rst README.rst config logging radicale.py radicale.fcgi radicale.wsgi schema.sql Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/NEWS.rst000066400000000000000000000130661264614074700213710ustar00rootroot00000000000000====== News ====== 1.1.1 - Second Law of Nature ============================ * Fix the owner_write rights rule 1.1 - Law of Nature =================== One feature in this release is **not backward compatible**: * Use the first matching section for rights (inspired from daald) Now, the first section matching the path and current user in your custom rights file is used. In the previous versions, the most permissive rights of all the matching sections were applied. This new behaviour gives a simple way to make specific rules at the top of the file independant from the generic ones. Many **improvements in this release are related to security**, you should upgrade Radicale as soon as possible: * Improve the regex used for well-known URIs (by Unrud) * Prevent regex injection in rights management (by Unrud) * Prevent crafted HTTP request from calling arbitrary functions (by Unrud) * Improve URI sanitation and conversion to filesystem path (by Unrud) * Decouple the daemon from its parent environment (by Unrud) Some bugs have been fixed and little enhancements have been added: * Assign new items to corret key (by Unrud) * Avoid race condition in PID file creation (by Unrud) * Improve the docker version (by cdpb) * Encode message and commiter for git commits * Test with Python 3.5 1.0.1 - Sunflower Again ======================= * Update the version because of a **stupid** "feature"™ of PyPI 1.0 - Sunflower =============== * Enhanced performances (by Mathieu Dupuy) * Add MD5-APR1 and BCRYPT for htpasswd-based authentication (by Jan-Philip Gehrcke) * Use PAM service (by Stephen Paul Weber) * Don't discard PROPPATCH on empty collections (by Markus Unterwaditzer) * Write the path of the collection in the git message (by Matthew Monaco) * Tests launched on Travis 0.10 - Lovely Endless Grass =========================== * Support well-known URLs (by Mathieu Dupuy) * Fix collection discovery (by Markus Unterwaditzer) * Reload logger config on SIGHUP (by Élie Bouttier) * Remove props files when deleting a collection (by Vincent Untz) * Support salted SHA1 passwords (by Marc Kleine-Budde) * Don't spam the logs about non-SSL IMAP connections to localhost (by Giel van Schijndel) 0.9 - Rivers ============ * Custom handlers for auth, storage and rights (by Sergey Fursov) * 1-file-per-event storage (by Jean-Marc Martins) * Git support for filesystem storages (by Jean-Marc Martins) * DB storage working with PostgreSQL, MariaDB and SQLite (by Jean-Marc Martins) * Clean rights manager based on regular expressions (by Sweil) * Support of contacts for Apple's clients * Support colors (by Jochen Sprickerhof) * Decode URLs in XML (by Jean-Marc Martins) * Fix PAM authentication (by Stepan Henek) * Use consistent etags (by 9m66p93w) * Use consistent sorting order (by Daniel Danner) * Return 401 on unauthorized DELETE requests (by Eduard Braun) * Move pid file creation in child process (by Mathieu Dupuy) * Allow requests without base_prefix (by jheidemann) 0.8 - Rainbow ============= * New authentication and rights management modules (by Matthias Jordan) * Experimental database storage * Command-line option for custom configuration file (by Mark Adams) * Root URL not at the root of a domain (by Clint Adams, Fabrice Bellet, Vincent Untz) * Improved support for iCal, CalDAVSync, CardDAVSync, CalDavZAP and CardDavMATE * Empty PROPFIND requests handled (by Christoph Polcin) * Colon allowed in passwords * Configurable realm message 0.7.1 - Waterfalls ================== * Many address books fixes * New IMAP ACL (by Daniel Aleksandersen) * PAM ACL fixed (by Daniel Aleksandersen) * Courier ACL fixed (by Benjamin Frank) * Always set display name to collections (by Oskari Timperi) * Various DELETE responses fixed 0.7 - Eternal Sunshine ====================== * Repeating events * Collection deletion * Courier and PAM authentication methods * CardDAV support * Custom LDAP filters supported 0.6.4 - Tulips ============== * Fix the installation with Python 3.1 0.6.3 - Red Roses ================= * MOVE requests fixed * Faster REPORT answers * Executable script moved into the package 0.6.2 - Seeds ============= * iPhone and iPad support fixed * Backslashes replaced by slashes in PROPFIND answers on Windows * PyPI archive set as default download URL 0.6.1 - Growing Up ================== * Example files included in the tarball * htpasswd support fixed * Redirection loop bug fixed * Testing message on GET requests 0.6 - Sapling ============= * WSGI support * IPv6 support * Smart, verbose and configurable logs * Apple iCal 4 and iPhone support (by Łukasz Langa) * KDE KOrganizer support * LDAP auth backend (by Corentin Le Bail) * Public and private calendars (by René Neumann) * PID file * MOVE requests management * Journal entries support * Drop Python 2.5 support 0.5 - Historical Artifacts ========================== * Calendar depth * MacOS and Windows support * HEAD requests management * htpasswd user from calendar path 0.4 - Hot Days Back =================== * Personal calendars * Last-Modified HTTP header * ``no-ssl`` and ``foreground`` options * Default configuration file 0.3 - Dancing Flowers ===================== * Evolution support * Version management 0.2 - Snowflakes ================ * Sunbird pre-1.0 support * SSL connection * Htpasswd authentication * Daemon mode * User configuration * Twisted dependency removed * Python 3 support * Real URLs for PUT and DELETE * Concurrent modification reported to users * Many bugs fixed (by Roger Wenham) 0.1 - Crazy Vegetables ====================== * First release * Lightning/Sunbird 0.9 compatibility * Easy installer Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/README000066400000000000000000000002631264614074700207360ustar00rootroot00000000000000Radicale is a free and open-source CalDAV and CardDAV server. For complete documentation, please visit the Radicale online documentation (http://www.radicale.org/documentation). Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/README.rst000066400000000000000000000003231264614074700215420ustar00rootroot00000000000000========= Read Me ========= Radicale is a free and open-source CalDAV and CardDAV server. For complete documentation, please visit the `Radicale online documentation `_ Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/TODO.rst000066400000000000000000000001531264614074700213530ustar00rootroot00000000000000============ To-Do List ============ 2.0 === * iCal filters and rights * CalDAV rights * CalDAV filters Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/bin/000077500000000000000000000000001264614074700206255ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/bin/radicale000077500000000000000000000017551264614074700223270ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale CalDAV Server. Launch the server according to configuration and command-line options. """ import radicale.__main__ radicale.__main__.run() Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/config000066400000000000000000000105441264614074700212510ustar00rootroot00000000000000# -*- mode: conf -*- # vim:ft=cfg # Config file for Radicale - A simple calendar server # # Place it into /etc/radicale/config (global) # or ~/.config/radicale/config (user) # # The current values are the default ones [server] # CalDAV server hostnames separated by a comma # IPv4 syntax: address:port # IPv6 syntax: [address]:port # For example: 0.0.0.0:9999, [::]:9999 # IPv6 adresses are configured to only allow IPv6 connections #hosts = 0.0.0.0:5232 # Daemon flag #daemon = False # File storing the PID in daemon mode #pid = # SSL flag, enable HTTPS protocol #ssl = False # SSL certificate path #certificate = /etc/apache2/ssl/server.crt # SSL private key #key = /etc/apache2/ssl/server.key # SSL Protocol used. See python's ssl module for available values #protocol = PROTOCOL_SSLv23 # Ciphers available. See python's ssl module for available ciphers #ciphers = # Reverse DNS to resolve client address in logs #dns_lookup = True # Root URL of Radicale (starting and ending with a slash) #base_prefix = / # Possibility to allow URLs cleaned by a HTTP server, without the base_prefix #can_skip_base_prefix = False # Message displayed in the client when a password is needed #realm = Radicale - Password Required [encoding] # Encoding for responding requests #request = utf-8 # Encoding for storing local collections #stock = utf-8 [well-known] # Path where /.well-known/caldav/ is redirected #caldav = '/%(user)s/caldav/' # Path where /.well-known/carddav/ is redirected #carddav = '/%(user)s/carddav/' [auth] # Authentication method # Value: None | htpasswd | IMAP | LDAP | PAM | courier | http | remote_user | custom #type = None # Custom authentication handler #custom_handler = # Htpasswd filename #htpasswd_filename = /etc/radicale/users # Htpasswd encryption method # Value: plain | sha1 | ssha | crypt | bcrypt | md5 #htpasswd_encryption = crypt # LDAP server URL, with protocol and port #ldap_url = ldap://localhost:389/ # LDAP base path #ldap_base = ou=users,dc=example,dc=com # LDAP login attribute #ldap_attribute = uid # LDAP filter string # placed as X in a query of the form (&(...)X) # example: (objectCategory=Person)(objectClass=User)(memberOf=cn=calenderusers,ou=users,dc=example,dc=org) # leave empty if no additional filter is needed #ldap_filter = # LDAP dn for initial login, used if LDAP server does not allow anonymous searches # Leave empty if searches are anonymous #ldap_binddn = # LDAP password for initial login, used with ldap_binddn #ldap_password = # LDAP scope of the search #ldap_scope = OneLevel # IMAP Configuration #imap_hostname = localhost #imap_port = 143 #imap_ssl = False # PAM group user should be member of #pam_group_membership = # Path to the Courier Authdaemon socket #courier_socket = # HTTP authentication request URL endpoint #http_url = # POST parameter to use for username #http_user_parameter = # POST parameter to use for password #http_password_parameter = [git] # Git default options #committer = Radicale [rights] # Rights backend # Value: None | authenticated | owner_only | owner_write | from_file | custom #type = None # Custom rights handler #custom_handler = # File for rights management from_file #file = ~/.config/radicale/rights [storage] # Storage backend # ------- # WARNING: ONLY "filesystem" IS DOCUMENTED AND TESTED, # OTHER BACKENDS ARE NOT READY FOR PRODUCTION. # ------- # Value: filesystem | multifilesystem | database | custom #type = filesystem # Custom storage handler #custom_handler = # Folder for storing local collections, created if not present #filesystem_folder = ~/.config/radicale/collections # Database URL for SQLAlchemy # dialect+driver://user:password@host/dbname[?key=value..] # For example: sqlite:///var/db/radicale.db, postgresql://user:password@localhost/radicale # See http://docs.sqlalchemy.org/en/rel_0_8/core/engines.html#sqlalchemy.create_engine #database_url = [logging] # Logging configuration file # If no config is given, simple information is printed on the standard output # For more information about the syntax of the configuration file, see: # http://docs.python.org/library/logging.config.html #config = /etc/radicale/logging # Set the default logging level to debug #debug = False # Store all environment variables (including those set in the shell) #full_environment = False [headers] # Additional HTTP headers #Access-Control-Allow-Origin = * Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/logging000066400000000000000000000020121264614074700214210ustar00rootroot00000000000000# -*- mode: conf -*- # vim:ft=cfg # Logging config file for Radicale - A simple calendar server # # The default path for this file is /etc/radicale/logging # This can be changed in the configuration file # # Other handlers are available. For more information, see: # http://docs.python.org/library/logging.config.html # Loggers, handlers and formatters keys [loggers] # Loggers names, main configuration slots keys = root [handlers] # Logging handlers, defining logging output methods keys = console,file [formatters] # Logging formatters keys = simple,full # Loggers [logger_root] # Root logger level = DEBUG handlers = console,file # Handlers [handler_console] # Console handler class = StreamHandler level = INFO args = (sys.stdout,) formatter = simple [handler_file] # File handler class = FileHandler args = ('/var/log/radicale',) formatter = full # Formatters [formatter_simple] # Simple output format format = %(message)s [formatter_full] # Full output format format = %(asctime)s - %(levelname)s: %(message)s Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale.fcgi000077500000000000000000000022401264614074700224540ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2011-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale FastCGI Example. Launch a Radicale FastCGI server according to configuration. """ try: from flup.server.fcgi import WSGIServer except ImportError: from flipflop import WSGIServer import radicale radicale.log.start() radicale.log.LOGGER.info("Starting Radicale FastCGI server") WSGIServer(radicale.Application()).run() radicale.log.LOGGER.info("Stopping Radicale FastCGI server") Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale.py000077500000000000000000000017551264614074700222060ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale CalDAV Server. Launch the server according to configuration and command-line options. """ import radicale.__main__ radicale.__main__.run() Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale.wsgi000077500000000000000000000016241264614074700225220ustar00rootroot00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2011-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale WSGI file (mod_wsgi and uWSGI compliant). """ import radicale radicale.log.start() application = radicale.Application() Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/000077500000000000000000000000001264614074700216215ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/__init__.py000066400000000000000000000565011264614074700237410ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2015 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale Server module. This module offers a WSGI application class. To use this module, you should take a look at the file ``radicale.py`` that should have been included in this package. """ import os import sys import pprint import base64 import socket import ssl import wsgiref.simple_server import re # Manage Python2/3 different modules # pylint: disable=F0401,E0611 try: from http import client from urllib.parse import unquote, urlparse except ImportError: import httplib as client from urllib import unquote from urlparse import urlparse # pylint: enable=F0401,E0611 from . import auth, config, ical, log, pathutils, rights, storage, xmlutils VERSION = "1.1.1" # Standard "not allowed" response that is returned when an authenticated user # tries to access information they don't have rights to NOT_ALLOWED = (client.FORBIDDEN, {}, None) WELL_KNOWN_RE = re.compile(r"/\.well-known/(carddav|caldav)/?$") class HTTPServer(wsgiref.simple_server.WSGIServer, object): """HTTP server.""" def __init__(self, address, handler, bind_and_activate=True): """Create server.""" ipv6 = ":" in address[0] if ipv6: self.address_family = socket.AF_INET6 # Do not bind and activate, as we might change socket options super(HTTPServer, self).__init__(address, handler, False) if ipv6: # Only allow IPv6 connections to the IPv6 socket self.socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1) if bind_and_activate: self.server_bind() self.server_activate() class HTTPSServer(HTTPServer): """HTTPS server.""" def __init__(self, address, handler): """Create server by wrapping HTTP socket in an SSL socket.""" super(HTTPSServer, self).__init__(address, handler, False) # Test if the SSL files can be read for name in ("certificate", "key"): filename = config.get("server", name) try: open(filename, "r").close() except IOError as exception: log.LOGGER.warning( "Error while reading SSL %s %r: %s" % ( name, filename, exception)) ssl_kwargs = dict( server_side=True, certfile=config.get("server", "certificate"), keyfile=config.get("server", "key"), ssl_version=getattr( ssl, config.get("server", "protocol"), ssl.PROTOCOL_SSLv23)) # add ciphers argument only if supported (Python 2.7+) if sys.version_info >= (2, 7): ssl_kwargs["ciphers"] = config.get("server", "ciphers") or None self.socket = ssl.wrap_socket(self.socket, **ssl_kwargs) self.server_bind() self.server_activate() class RequestHandler(wsgiref.simple_server.WSGIRequestHandler): """HTTP requests handler.""" def log_message(self, *args, **kwargs): """Disable inner logging management.""" def address_string(self): """Client address, formatted for logging.""" if config.getboolean("server", "dns_lookup"): return \ wsgiref.simple_server.WSGIRequestHandler.address_string(self) else: return self.client_address[0] class Application(object): """WSGI application managing collections.""" def __init__(self): """Initialize application.""" super(Application, self).__init__() auth.load() storage.load() rights.load() self.encoding = config.get("encoding", "request") if config.getboolean("logging", "full_environment"): self.headers_log = lambda environ: environ # This method is overriden in __init__ if full_environment is set # pylint: disable=E0202 @staticmethod def headers_log(environ): """Remove environment variables from the headers for logging.""" request_environ = dict(environ) for shell_variable in os.environ: if shell_variable in request_environ: del request_environ[shell_variable] return request_environ # pylint: enable=E0202 def decode(self, text, environ): """Try to magically decode ``text`` according to given ``environ``.""" # List of charsets to try charsets = [] # First append content charset given in the request content_type = environ.get("CONTENT_TYPE") if content_type and "charset=" in content_type: charsets.append( content_type.split("charset=")[1].split(";")[0].strip()) # Then append default Radicale charset charsets.append(self.encoding) # Then append various fallbacks charsets.append("utf-8") charsets.append("iso8859-1") # Try to decode for charset in charsets: try: return text.decode(charset) except UnicodeDecodeError: pass raise UnicodeDecodeError @staticmethod def sanitize_uri(uri): """Unquote and make absolute to prevent access to other data.""" uri = unquote(uri) return pathutils.sanitize_path(uri) def collect_allowed_items(self, items, user): """Get items from request that user is allowed to access.""" read_last_collection_allowed = None write_last_collection_allowed = None read_allowed_items = [] write_allowed_items = [] for item in items: if isinstance(item, ical.Collection): if rights.authorized(user, item, "r"): log.LOGGER.debug( "%s has read access to collection %s" % (user or "Anonymous", item.url or "/")) read_last_collection_allowed = True read_allowed_items.append(item) else: log.LOGGER.debug( "%s has NO read access to collection %s" % (user or "Anonymous", item.url or "/")) read_last_collection_allowed = False if rights.authorized(user, item, "w"): log.LOGGER.debug( "%s has write access to collection %s" % (user or "Anonymous", item.url or "/")) write_last_collection_allowed = True write_allowed_items.append(item) else: log.LOGGER.debug( "%s has NO write access to collection %s" % (user or "Anonymous", item.url or "/")) write_last_collection_allowed = False else: # item is not a collection, it's the child of the last # collection we've met in the loop. Only add this item # if this last collection was allowed. if read_last_collection_allowed: log.LOGGER.debug( "%s has read access to item %s" % (user or "Anonymous", item.name)) read_allowed_items.append(item) else: log.LOGGER.debug( "%s has NO read access to item %s" % (user or "Anonymous", item.name)) if write_last_collection_allowed: log.LOGGER.debug( "%s has write access to item %s" % (user or "Anonymous", item.name)) write_allowed_items.append(item) else: log.LOGGER.debug( "%s has NO write access to item %s" % (user or "Anonymous", item.name)) return read_allowed_items, write_allowed_items def __call__(self, environ, start_response): """Manage a request.""" log.LOGGER.info("%s request at %s received" % ( environ["REQUEST_METHOD"], environ["PATH_INFO"])) headers = pprint.pformat(self.headers_log(environ)) log.LOGGER.debug("Request headers:\n%s" % headers) # Strip base_prefix from request URI base_prefix = config.get("server", "base_prefix") if environ["PATH_INFO"].startswith(base_prefix): environ["PATH_INFO"] = environ["PATH_INFO"][len(base_prefix):] elif config.get("server", "can_skip_base_prefix"): log.LOGGER.debug( "Prefix already stripped from path: %s", environ["PATH_INFO"]) else: # Request path not starting with base_prefix, not allowed log.LOGGER.debug( "Path not starting with prefix: %s", environ["PATH_INFO"]) status, headers, _ = NOT_ALLOWED start_response(status, list(headers.items())) return [] # Sanitize request URI environ["PATH_INFO"] = self.sanitize_uri(environ["PATH_INFO"]) log.LOGGER.debug("Sanitized path: %s", environ["PATH_INFO"]) path = environ["PATH_INFO"] # Get function corresponding to method function = getattr(self, "do_%s" % environ["REQUEST_METHOD"].upper()) # Ask authentication backend to check rights authorization = environ.get("HTTP_AUTHORIZATION", None) if authorization: authorization = authorization.lstrip("Basic").strip() user, password = self.decode(base64.b64decode( authorization.encode("ascii")), environ).split(":", 1) else: user = environ.get("REMOTE_USER") password = None well_known = WELL_KNOWN_RE.match(path) if well_known: redirect = config.get("well-known", well_known.group(1)) try: redirect = redirect % ({"user": user} if user else {}) except KeyError: status = client.UNAUTHORIZED headers = { "WWW-Authenticate": "Basic realm=\"%s\"" % config.get("server", "realm")} log.LOGGER.info( "Refused /.well-known/ redirection to anonymous user") else: status = client.SEE_OTHER log.LOGGER.info("/.well-known/ redirection to: %s" % redirect) if sys.version_info < (3, 0): redirect = redirect.encode(self.encoding) headers = {"Location": redirect} status = "%i %s" % ( status, client.responses.get(status, "Unknown")) start_response(status, list(headers.items())) return [] is_authenticated = auth.is_authenticated(user, password) is_valid_user = is_authenticated or not user if is_valid_user: items = ical.Collection.from_path( path, environ.get("HTTP_DEPTH", "0")) read_allowed_items, write_allowed_items = \ self.collect_allowed_items(items, user) else: read_allowed_items, write_allowed_items = None, None # Get content content_length = int(environ.get("CONTENT_LENGTH") or 0) if content_length: content = self.decode( environ["wsgi.input"].read(content_length), environ) log.LOGGER.debug("Request content:\n%s" % content) else: content = None if is_valid_user and ( (read_allowed_items or write_allowed_items) or (is_authenticated and function == self.do_PROPFIND) or function == self.do_OPTIONS): status, headers, answer = function( environ, read_allowed_items, write_allowed_items, content, user) else: status, headers, answer = NOT_ALLOWED if ((status, headers, answer) == NOT_ALLOWED and not auth.is_authenticated(user, password) and config.get("auth", "type") != "None"): # Unknown or unauthorized user log.LOGGER.info("%s refused" % (user or "Anonymous user")) status = client.UNAUTHORIZED headers = { "WWW-Authenticate": "Basic realm=\"%s\"" % config.get("server", "realm")} answer = None # Set content length if answer: log.LOGGER.debug( "Response content:\n%s" % self.decode(answer, environ)) headers["Content-Length"] = str(len(answer)) if config.has_section("headers"): for key in config.options("headers"): headers[key] = config.get("headers", key) # Start response status = "%i %s" % (status, client.responses.get(status, "Unknown")) log.LOGGER.debug("Answer status: %s" % status) start_response(status, list(headers.items())) # Return response content return [answer] if answer else [] # All these functions must have the same parameters, some are useless # pylint: disable=W0612,W0613,R0201 def do_DELETE(self, environ, read_collections, write_collections, content, user): """Manage DELETE request.""" if not len(write_collections): return NOT_ALLOWED collection = write_collections[0] if collection.path == environ["PATH_INFO"].strip("/"): # Path matching the collection, the collection must be deleted item = collection else: # Try to get an item matching the path name = xmlutils.name_from_path(environ["PATH_INFO"], collection) item = collection.items.get(name) if item: # Evolution bug workaround if_match = environ.get("HTTP_IF_MATCH", "*").replace("\\", "") if if_match in ("*", item.etag): # No ETag precondition or precondition verified, delete item answer = xmlutils.delete(environ["PATH_INFO"], collection) return client.OK, {}, answer # No item or ETag precondition not verified, do not delete item return client.PRECONDITION_FAILED, {}, None def do_GET(self, environ, read_collections, write_collections, content, user): """Manage GET request. In Radicale, GET requests create collections when the URL is not available. This is useful for clients with no MKCOL or MKCALENDAR support. """ # Display a "Radicale works!" message if the root URL is requested if environ["PATH_INFO"] == "/": headers = {"Content-type": "text/html"} answer = b"\nRadicaleRadicale works!" return client.OK, headers, answer if not len(read_collections): return NOT_ALLOWED collection = read_collections[0] item_name = xmlutils.name_from_path(environ["PATH_INFO"], collection) if item_name: # Get collection item item = collection.items.get(item_name) if item: items = [item] if collection.resource_type == "calendar": items.extend(collection.timezones) answer_text = ical.serialize( collection.tag, collection.headers, items) etag = item.etag else: return client.NOT_FOUND, {}, None else: # Create the collection if it does not exist if not collection.exists: if collection in write_collections: log.LOGGER.debug( "Creating collection %s" % collection.name) collection.write() else: log.LOGGER.debug( "Collection %s not available and could not be created " "due to missing write rights" % collection.name) return NOT_ALLOWED # Get whole collection answer_text = collection.text etag = collection.etag headers = { "Content-Type": collection.mimetype, "Last-Modified": collection.last_modified, "ETag": etag} answer = answer_text.encode(self.encoding) return client.OK, headers, answer def do_HEAD(self, environ, read_collections, write_collections, content, user): """Manage HEAD request.""" status, headers, answer = self.do_GET( environ, read_collections, write_collections, content, user) return status, headers, None def do_MKCALENDAR(self, environ, read_collections, write_collections, content, user): """Manage MKCALENDAR request.""" if not len(write_collections): return NOT_ALLOWED collection = write_collections[0] props = xmlutils.props_from_request(content) timezone = props.get("C:calendar-timezone") if timezone: collection.replace("", timezone) del props["C:calendar-timezone"] with collection.props as collection_props: for key, value in props.items(): collection_props[key] = value collection.write() return client.CREATED, {}, None def do_MKCOL(self, environ, read_collections, write_collections, content, user): """Manage MKCOL request.""" if not len(write_collections): return NOT_ALLOWED collection = write_collections[0] props = xmlutils.props_from_request(content) with collection.props as collection_props: for key, value in props.items(): collection_props[key] = value collection.write() return client.CREATED, {}, None def do_MOVE(self, environ, read_collections, write_collections, content, user): """Manage MOVE request.""" if not len(write_collections): return NOT_ALLOWED from_collection = write_collections[0] from_name = xmlutils.name_from_path( environ["PATH_INFO"], from_collection) if from_name: item = from_collection.items.get(from_name) if item: # Move the item to_url_parts = urlparse(environ["HTTP_DESTINATION"]) if to_url_parts.netloc == environ["HTTP_HOST"]: to_url = to_url_parts.path to_path, to_name = to_url.rstrip("/").rsplit("/", 1) to_collection = ical.Collection.from_path( to_path, depth="0")[0] if to_collection in write_collections: to_collection.append(to_name, item.text) from_collection.remove(from_name) return client.CREATED, {}, None else: return NOT_ALLOWED else: # Remote destination server, not supported return client.BAD_GATEWAY, {}, None else: # No item found return client.GONE, {}, None else: # Moving collections, not supported return client.FORBIDDEN, {}, None def do_OPTIONS(self, environ, read_collections, write_collections, content, user): """Manage OPTIONS request.""" headers = { "Allow": ("DELETE, HEAD, GET, MKCALENDAR, MKCOL, MOVE, " "OPTIONS, PROPFIND, PROPPATCH, PUT, REPORT"), "DAV": "1, 2, 3, calendar-access, addressbook, extended-mkcol"} return client.OK, headers, None def do_PROPFIND(self, environ, read_collections, write_collections, content, user): """Manage PROPFIND request.""" # Rights is handled by collection in xmlutils.propfind headers = { "DAV": "1, 2, 3, calendar-access, addressbook, extended-mkcol", "Content-Type": "text/xml"} collections = set(read_collections + write_collections) answer = xmlutils.propfind( environ["PATH_INFO"], content, collections, user) return client.MULTI_STATUS, headers, answer def do_PROPPATCH(self, environ, read_collections, write_collections, content, user): """Manage PROPPATCH request.""" if not len(write_collections): return NOT_ALLOWED collection = write_collections[0] answer = xmlutils.proppatch( environ["PATH_INFO"], content, collection) headers = { "DAV": "1, 2, 3, calendar-access, addressbook, extended-mkcol", "Content-Type": "text/xml"} return client.MULTI_STATUS, headers, answer def do_PUT(self, environ, read_collections, write_collections, content, user): """Manage PUT request.""" if not len(write_collections): return NOT_ALLOWED collection = write_collections[0] collection.set_mimetype(environ.get("CONTENT_TYPE")) headers = {} item_name = xmlutils.name_from_path(environ["PATH_INFO"], collection) item = collection.items.get(item_name) # Evolution bug workaround etag = environ.get("HTTP_IF_MATCH", "").replace("\\", "") match = environ.get("HTTP_IF_NONE_MATCH", "") == "*" if (not item and not etag) or ( item and ((etag or item.etag) == item.etag) and not match): # PUT allowed in 3 cases # Case 1: No item and no ETag precondition: Add new item # Case 2: Item and ETag precondition verified: Modify item # Case 3: Item and no Etag precondition: Force modifying item xmlutils.put(environ["PATH_INFO"], content, collection) status = client.CREATED # Try to return the etag in the header. # If the added item doesn't have the same name as the one given # by the client, then there's no obvious way to generate an # etag, we can safely ignore it. new_item = collection.items.get(item_name) if new_item: headers["ETag"] = new_item.etag else: # PUT rejected in all other cases status = client.PRECONDITION_FAILED return status, headers, None def do_REPORT(self, environ, read_collections, write_collections, content, user): """Manage REPORT request.""" if not len(read_collections): return NOT_ALLOWED collection = read_collections[0] headers = {"Content-Type": "text/xml"} answer = xmlutils.report(environ["PATH_INFO"], content, collection) return client.MULTI_STATUS, headers, answer # pylint: enable=W0612,W0613,R0201 Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/__main__.py000066400000000000000000000160321264614074700237150ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2011-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale executable module. This module can be executed from a command line with ``$python -m radicale`` or from a python programme with ``radicale.__main__.run()``. """ import atexit import os import sys import optparse import signal import threading from wsgiref.simple_server import make_server from . import ( Application, config, HTTPServer, HTTPSServer, log, RequestHandler, VERSION) # This is a script, many branches and variables # pylint: disable=R0912,R0914 def run(): """Run Radicale as a standalone server.""" # Get command-line options parser = optparse.OptionParser(version=VERSION) parser.add_option( "-d", "--daemon", action="store_true", help="launch as daemon") parser.add_option( "-p", "--pid", help="set PID filename for daemon mode") parser.add_option( "-f", "--foreground", action="store_false", dest="daemon", help="launch in foreground (opposite of --daemon)") parser.add_option( "-H", "--hosts", help="set server hostnames and ports") parser.add_option( "-s", "--ssl", action="store_true", help="use SSL connection") parser.add_option( "-S", "--no-ssl", action="store_false", dest="ssl", help="do not use SSL connection (opposite of --ssl)") parser.add_option( "-k", "--key", help="set private key file") parser.add_option( "-c", "--certificate", help="set certificate file") parser.add_option( "-D", "--debug", action="store_true", help="print debug information") parser.add_option( "-C", "--config", help="use a specific configuration file") options = parser.parse_args()[0] # Read in the configuration specified by the command line (if specified) configuration_found = ( config.read(options.config) if options.config else True) # Update Radicale configuration according to options for option in parser.option_list: key = option.dest if key: section = "logging" if key == "debug" else "server" value = getattr(options, key) if value is not None: config.set(section, key, str(value)) # Start logging log.start() # Log a warning if the configuration file of the command line is not found if not configuration_found: log.LOGGER.warning( "Configuration file '%s' not found" % options.config) # Fork if Radicale is launched as daemon if config.getboolean("server", "daemon"): # Check and create PID file in a race-free manner if config.get("server", "pid"): try: pid_fd = os.open( config.get("server", "pid"), os.O_CREAT | os.O_EXCL | os.O_WRONLY) except: raise OSError( "PID file exists: %s" % config.get("server", "pid")) pid = os.fork() if pid: sys.exit() # Write PID if config.get("server", "pid"): with os.fdopen(pid_fd, "w") as pid_file: pid_file.write(str(os.getpid())) # Decouple environment os.umask(0) os.chdir("/") os.setsid() with open(os.devnull, "r") as null_in: os.dup2(null_in.fileno(), sys.stdin.fileno()) with open(os.devnull, "w") as null_out: os.dup2(null_out.fileno(), sys.stdout.fileno()) os.dup2(null_out.fileno(), sys.stderr.fileno()) # Register exit function def cleanup(): """Remove the PID files.""" log.LOGGER.debug("Cleaning up") # Remove PID file if (config.get("server", "pid") and config.getboolean("server", "daemon")): os.unlink(config.get("server", "pid")) atexit.register(cleanup) log.LOGGER.info("Starting Radicale") # Create collection servers servers = [] server_class = ( HTTPSServer if config.getboolean("server", "ssl") else HTTPServer) shutdown_program = threading.Event() for host in config.get("server", "hosts").split(","): address, port = host.strip().rsplit(":", 1) address, port = address.strip("[] "), int(port) servers.append( make_server(address, port, Application(), server_class, RequestHandler)) # SIGTERM and SIGINT (aka KeyboardInterrupt) should just mark this for # shutdown signal.signal(signal.SIGTERM, lambda *_: shutdown_program.set()) signal.signal(signal.SIGINT, lambda *_: shutdown_program.set()) def serve_forever(server): """Serve a server forever, cleanly shutdown when things go wrong.""" try: server.serve_forever() finally: shutdown_program.set() log.LOGGER.debug( "Base URL prefix: %s" % config.get("server", "base_prefix")) # Start the servers in a different loop to avoid possible race-conditions, # when a server exists but another server is added to the list at the same # time for server in servers: log.LOGGER.debug( "Listening to %s port %s" % ( server.server_name, server.server_port)) if config.getboolean("server", "ssl"): log.LOGGER.debug("Using SSL") threading.Thread(target=serve_forever, args=(server,)).start() log.LOGGER.debug("Radicale server ready") # Main loop: wait until all servers are exited try: # We must do the busy-waiting here, as all ``.join()`` calls completly # block the thread, such that signals are not received while True: # The number is irrelevant, it only needs to be greater than 0.05 # due to python implementing its own busy-waiting logic shutdown_program.wait(5.0) if shutdown_program.is_set(): break finally: # Ignore signals, so that they cannot interfere signal.signal(signal.SIGINT, signal.SIG_IGN) signal.signal(signal.SIGTERM, signal.SIG_IGN) log.LOGGER.info("Stopping Radicale") for server in servers: log.LOGGER.debug( "Closing server listening to %s port %s" % ( server.server_name, server.server_port)) server.shutdown() # pylint: enable=R0912,R0914 if __name__ == "__main__": run() Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/000077500000000000000000000000001264614074700225625ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/IMAP.py000066400000000000000000000071201264614074700236620ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012 Daniel Aleksandersen # Copyright © 2013 Nikita Koshikov # Copyright © 2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ IMAP authentication. Secure authentication based on the ``imaplib`` module. Validating users against a modern IMAP4rev1 server that awaits STARTTLS on port 143. Legacy SSL (often on legacy port 993) is deprecated and thus unsupported. STARTTLS is enforced except if host is ``localhost`` as passwords are sent in PLAIN. Python 3.2 or newer is required for TLS. """ import imaplib from .. import config, log IMAP_SERVER = config.get("auth", "imap_hostname") IMAP_SERVER_PORT = config.getint("auth", "imap_port") IMAP_USE_SSL = config.getboolean("auth", "imap_ssl") IMAP_WARNED_UNENCRYPTED = False def is_authenticated(user, password): """Check if ``user``/``password`` couple is valid.""" global IMAP_WARNED_UNENCRYPTED if not user or not password: return False log.LOGGER.debug( "Connecting to IMAP server %s:%s." % (IMAP_SERVER, IMAP_SERVER_PORT,)) connection_is_secure = False if IMAP_USE_SSL: connection = imaplib.IMAP4_SSL(host=IMAP_SERVER, port=IMAP_SERVER_PORT) connection_is_secure = True else: connection = imaplib.IMAP4(host=IMAP_SERVER, port=IMAP_SERVER_PORT) server_is_local = (IMAP_SERVER == "localhost") if not connection_is_secure: try: connection.starttls() log.LOGGER.debug("IMAP server connection changed to TLS.") connection_is_secure = True except AttributeError: if not server_is_local: log.LOGGER.error( "Python 3.2 or newer is required for IMAP + TLS.") except (imaplib.IMAP4.error, imaplib.IMAP4.abort) as exception: log.LOGGER.warning( "IMAP server at %s failed to accept TLS connection " "because of: %s" % (IMAP_SERVER, exception)) if server_is_local and not connection_is_secure and not IMAP_WARNED_UNENCRYPTED: IMAP_WARNED_UNENCRYPTED = True log.LOGGER.warning( "IMAP server is local. " "Will allow transmitting unencrypted credentials.") if connection_is_secure or server_is_local: try: connection.login(user, password) connection.logout() log.LOGGER.debug( "Authenticated IMAP user %s " "via %s." % (user, IMAP_SERVER)) return True except (imaplib.IMAP4.error, imaplib.IMAP4.abort) as exception: log.LOGGER.error( "IMAP server could not authenticate user %s " "because of: %s" % (user, exception)) else: log.LOGGER.critical( "IMAP server did not support TLS and is not ``localhost``. " "Refusing to transmit passwords under these conditions. " "Authentication attempt aborted.") return False # authentication failed Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/LDAP.py000066400000000000000000000050461264614074700236610ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2011 Corentin Le Bail # Copyright © 2011-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ LDAP authentication. Authentication based on the ``python-ldap`` module (http://www.python-ldap.org/). """ import ldap from .. import config, log BASE = config.get("auth", "ldap_base") ATTRIBUTE = config.get("auth", "ldap_attribute") FILTER = config.get("auth", "ldap_filter") CONNEXION = ldap.initialize(config.get("auth", "ldap_url")) BINDDN = config.get("auth", "ldap_binddn") PASSWORD = config.get("auth", "ldap_password") SCOPE = getattr(ldap, "SCOPE_%s" % config.get("auth", "ldap_scope").upper()) def is_authenticated(user, password): """Check if ``user``/``password`` couple is valid.""" global CONNEXION try: CONNEXION.whoami_s() except: log.LOGGER.debug("Reconnecting the LDAP server") CONNEXION = ldap.initialize(config.get("auth", "ldap_url")) if BINDDN and PASSWORD: log.LOGGER.debug("Initial LDAP bind as %s" % BINDDN) CONNEXION.simple_bind_s(BINDDN, PASSWORD) distinguished_name = "%s=%s" % (ATTRIBUTE, ldap.dn.escape_dn_chars(user)) log.LOGGER.debug( "LDAP bind for %s in base %s" % (distinguished_name, BASE)) if FILTER: filter_string = "(&(%s)%s)" % (distinguished_name, FILTER) else: filter_string = distinguished_name log.LOGGER.debug("Used LDAP filter: %s" % filter_string) users = CONNEXION.search_s(BASE, SCOPE, filter_string) if users: log.LOGGER.debug("User %s found" % user) try: CONNEXION.simple_bind_s(users[0][0], password or "") except ldap.LDAPError: log.LOGGER.debug("Invalid credentials") else: log.LOGGER.debug("LDAP bind OK") return True else: log.LOGGER.debug("User %s not found" % user) log.LOGGER.debug("LDAP bind failed") return False Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/PAM.py000066400000000000000000000054141264614074700235550ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2011 Henry-Nicolas Tourneur # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ PAM authentication. Authentication based on the ``pam-python`` module. """ import grp import pam import pwd from .. import config, log GROUP_MEMBERSHIP = config.get("auth", "pam_group_membership") # Compatibility for old versions of python-pam. if hasattr(pam, "pam"): def pam_authenticate(*args, **kwargs): return pam.pam().authenticate(*args, **kwargs) else: def pam_authenticate(*args, **kwargs): return pam.authenticate(*args, **kwargs) def is_authenticated(user, password): """Check if ``user``/``password`` couple is valid.""" if user is None or password is None: return False # Check whether the user exists in the PAM system try: pwd.getpwnam(user).pw_uid except KeyError: log.LOGGER.debug("User %s not found" % user) return False else: log.LOGGER.debug("User %s found" % user) # Check whether the group exists try: # Obtain supplementary groups members = grp.getgrnam(GROUP_MEMBERSHIP).gr_mem except KeyError: log.LOGGER.debug( "The PAM membership required group (%s) doesn't exist" % GROUP_MEMBERSHIP) return False # Check whether the user exists try: # Get user primary group primary_group = grp.getgrgid(pwd.getpwnam(user).pw_gid).gr_name except KeyError: log.LOGGER.debug("The PAM user (%s) doesn't exist" % user) return False # Check whether the user belongs to the required group # (primary or supplementary) if primary_group == GROUP_MEMBERSHIP or user in members: log.LOGGER.debug( "The PAM user belongs to the required group (%s)" % GROUP_MEMBERSHIP) # Check the password if pam_authenticate(user, password, service='radicale'): return True else: log.LOGGER.debug("Wrong PAM password") else: log.LOGGER.debug( "The PAM user doesn't belong to the required group (%s)" % GROUP_MEMBERSHIP) return False Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/__init__.py000066400000000000000000000033701264614074700246760ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Authentication management. """ import sys from .. import config, log def load(): """Load list of available authentication managers.""" auth_type = config.get("auth", "type") log.LOGGER.debug("Authentication type is %s" % auth_type) if auth_type == "None": return None elif auth_type == 'custom': auth_module = config.get("auth", "custom_handler") __import__(auth_module) module = sys.modules[auth_module] else: root_module = __import__( "auth.%s" % auth_type, globals=globals(), level=2) module = getattr(root_module, auth_type) # Override auth.is_authenticated sys.modules[__name__].is_authenticated = module.is_authenticated return module def is_authenticated(user, password): """Check if the user is authenticated. This method is overriden if an auth module is loaded. """ return True # Default is always True: no authentication Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/courier.py000066400000000000000000000040551264614074700246100ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2011 Henry-Nicolas Tourneur # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Courier-Authdaemon authentication. """ import sys import socket from .. import config, log COURIER_SOCKET = config.get("auth", "courier_socket") def is_authenticated(user, password): """Check if ``user``/``password`` couple is valid.""" if not user or not password: return False line = "%s\nlogin\n%s\n%s" % (sys.argv[0], user, password) line = "AUTH %i\n%s" % (len(line), line) try: sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock.connect(COURIER_SOCKET) log.LOGGER.debug("Sending to Courier socket the request: %s" % line) sock.send(line) data = sock.recv(1024) sock.close() except socket.error as exception: log.LOGGER.debug( "Unable to communicate with Courier socket: %s" % exception) return False log.LOGGER.debug("Got Courier socket response: %r" % data) # Address, HOME, GID, and either UID or USERNAME are mandatory in resposne # see http://www.courier-mta.org/authlib/README_authlib.html#authpipeproto for line in data.split(): if "GID" in line: return True # default is reject # this alleviates the problem of a possibly empty reply from authlib # see http://www.courier-mta.org/authlib/README_authlib.html#authpipeproto return False Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/htpasswd.py000066400000000000000000000140731264614074700247760ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Implement htpasswd authentication. Apache's htpasswd command (httpd.apache.org/docs/programs/htpasswd.html) manages a file for storing user credentials. It can encrypt passwords using different methods, e.g. BCRYPT, MD5-APR1 (a version of MD5 modified for Apache), SHA1, or by using the system's CRYPT routine. The CRYPT and SHA1 encryption methods implemented by htpasswd are considered as insecure. MD5-APR1 provides medium security as of 2015. Only BCRYPT can be considered secure by current standards. MD5-APR1-encrypted credentials can be written by all versions of htpasswd (its the default, in fact), whereas BCRYPT requires htpasswd 2.4.x or newer. The `is_authenticated(user, password)` function provided by this module verifies the user-given credentials by parsing the htpasswd credential file pointed to by the ``htpasswd_filename`` configuration value while assuming the password encryption method specified via the ``htpasswd_encryption`` configuration value. The following htpasswd password encrpytion methods are supported by Radicale out-of-the-box: - plain-text (created by htpasswd -p...) -- INSECURE - CRYPT (created by htpasswd -d...) -- INSECURE - SHA1 (created by htpasswd -s...) -- INSECURE When passlib (https://pypi.python.org/pypi/passlib) is importable, the following significantly more secure schemes are parsable by Radicale: - MD5-APR1 (htpasswd -m...) -- htpasswd's default method - BCRYPT (htpasswd -B...) -- Requires htpasswd 2.4.x """ import base64 import hashlib import os from .. import config FILENAME = os.path.expanduser(config.get("auth", "htpasswd_filename")) ENCRYPTION = config.get("auth", "htpasswd_encryption") def _plain(hash_value, password): """Check if ``hash_value`` and ``password`` match, using plain method.""" return hash_value == password def _crypt(hash_value, password): """Check if ``hash_value`` and ``password`` match, using crypt method.""" return crypt.crypt(password, hash_value) == hash_value def _sha1(hash_value, password): """Check if ``hash_value`` and ``password`` match, using sha1 method.""" hash_value = hash_value.replace("{SHA}", "").encode("ascii") password = password.encode(config.get("encoding", "stock")) sha1 = hashlib.sha1() # pylint: disable=E1101 sha1.update(password) return sha1.digest() == base64.b64decode(hash_value) def _ssha(hash_salt_value, password): """Check if ``hash_salt_value`` and ``password`` match, using salted sha1 method. This method is not directly supported by htpasswd, but it can be written with e.g. openssl, and nginx can parse it.""" hash_salt_value = hash_salt_value.replace( "{SSHA}", "").encode("ascii").decode('base64') password = password.encode(config.get("encoding", "stock")) hash_value = hash_salt_value[:20] salt_value = hash_salt_value[20:] sha1 = hashlib.sha1() # pylint: disable=E1101 sha1.update(password) sha1.update(salt_value) return sha1.digest() == hash_value def _bcrypt(hash_value, password): return _passlib_bcrypt.verify(password, hash_value) def _md5apr1(hash_value, password): return _passlib_md5apr1.verify(password, hash_value) # Prepare mapping between encryption names and verification functions. # Pre-fill with methods that do not have external dependencies. _verifuncs = { "ssha": _ssha, "sha1": _sha1, "plain": _plain} # Conditionally attempt to import external dependencies. if ENCRYPTION == "md5": try: from passlib.hash import apr_md5_crypt as _passlib_md5apr1 except ImportError: raise RuntimeError(("The htpasswd_encryption method 'md5' requires " "availability of the passlib module.")) _verifuncs["md5"] = _md5apr1 elif ENCRYPTION == "bcrypt": try: from passlib.hash import bcrypt as _passlib_bcrypt except ImportError: raise RuntimeError(("The htpasswd_encryption method 'bcrypt' requires " "availability of the passlib module with bcrypt support.")) # A call to `encrypt` raises passlib.exc.MissingBackendError with a good # error message if bcrypt backend is not available. Trigger this here. _passlib_bcrypt.encrypt("test-bcrypt-backend") _verifuncs["bcrypt"] = _bcrypt elif ENCRYPTION == "crypt": try: import crypt except ImportError: raise RuntimeError(("The htpasswd_encryption method 'crypt' requires " "crypt() system support.")) _verifuncs["crypt"] = _crypt # Validate initial configuration. if ENCRYPTION not in _verifuncs: raise RuntimeError(("The htpasswd encryption method '%s' is not " "supported." % ENCRYPTION)) def is_authenticated(user, password): """Validate credentials. Iterate through htpasswd credential file until user matches, extract hash (encrypted password) and check hash against user-given password, using the method specified in the Radicale config. """ with open(FILENAME) as f: for line in f: strippedline = line.strip() if strippedline: login, hash_value = strippedline.split(":") if login == user: # Allow encryption method to be overridden at runtime. return _verifuncs[ENCRYPTION](hash_value, password) return False Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/http.py000066400000000000000000000027351264614074700241220ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012 Ehsanul Hoque # Copyright © 2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ HTTP authentication. Authentication based on the ``requests`` module. Post a request to an authentication server with the username/password. Anything other than a 200/201 response is considered auth failure. """ import requests from .. import config, log AUTH_URL = config.get("auth", "http_url") USER_PARAM = config.get("auth", "http_user_parameter") PASSWORD_PARAM = config.get("auth", "http_password_parameter") def is_authenticated(user, password): """Check if ``user``/``password`` couple is valid.""" log.LOGGER.debug("HTTP-based auth on %s." % AUTH_URL) payload = {USER_PARAM: user, PASSWORD_PARAM: password} return requests.post(AUTH_URL, data=payload).status_code in (200, 201) Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/auth/remote_user.py000066400000000000000000000020311264614074700254610ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012 Ehsanul Hoque # Copyright © 2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Trusting the HTTP server auth mechanism. """ from .. import log def is_authenticated(user, password): """Check if ``user`` is defined and assuming it's valid.""" log.LOGGER.debug("Got user %r from HTTP server." % user) return user is not None Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/config.py000066400000000000000000000067461264614074700234550ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008-2015 Guillaume Ayoub # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale configuration module. Give a configparser-like interface to read and write configuration. """ import os import sys # Manage Python2/3 different modules # pylint: disable=F0401 try: from configparser import RawConfigParser as ConfigParser except ImportError: from ConfigParser import RawConfigParser as ConfigParser # pylint: enable=F0401 # Default configuration INITIAL_CONFIG = { "server": { "hosts": "0.0.0.0:5232", "daemon": "False", "pid": "", "ssl": "False", "certificate": "/etc/apache2/ssl/server.crt", "key": "/etc/apache2/ssl/server.key", "protocol": "PROTOCOL_SSLv23", "ciphers": "", "dns_lookup": "True", "base_prefix": "/", "can_skip_base_prefix": "False", "realm": "Radicale - Password Required"}, "well-known": { "caldav": "/%(user)s/caldav/", "carddav": "/%(user)s/carddav/"}, "encoding": { "request": "utf-8", "stock": "utf-8"}, "auth": { "type": "None", "custom_handler": "", "htpasswd_filename": "/etc/radicale/users", "htpasswd_encryption": "crypt", "imap_hostname": "localhost", "imap_port": "143", "imap_ssl": "False", "ldap_url": "ldap://localhost:389/", "ldap_base": "ou=users,dc=example,dc=com", "ldap_attribute": "uid", "ldap_filter": "", "ldap_binddn": "", "ldap_password": "", "ldap_scope": "OneLevel", "pam_group_membership": "", "courier_socket": "", "http_url": "", "http_user_parameter": "", "http_password_parameter": ""}, "git": { "committer": "Radicale "}, "rights": { "type": "None", "custom_handler": "", "file": "~/.config/radicale/rights"}, "storage": { "type": "filesystem", "custom_handler": "", "filesystem_folder": os.path.expanduser( "~/.config/radicale/collections"), "database_url": ""}, "logging": { "config": "/etc/radicale/logging", "debug": "False", "full_environment": "False"}} # Create a ConfigParser and configure it _CONFIG_PARSER = ConfigParser() for section, values in INITIAL_CONFIG.items(): _CONFIG_PARSER.add_section(section) for key, value in values.items(): _CONFIG_PARSER.set(section, key, value) _CONFIG_PARSER.read("/etc/radicale/config") _CONFIG_PARSER.read(os.path.expanduser("~/.config/radicale/config")) if "RADICALE_CONFIG" in os.environ: _CONFIG_PARSER.read(os.environ["RADICALE_CONFIG"]) # Wrap config module into ConfigParser instance sys.modules[__name__] = _CONFIG_PARSER Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/ical.py000066400000000000000000000355241264614074700231140ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2015 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale collection classes. Define the main classes of a collection as seen from the server. """ import os import hashlib import re from uuid import uuid4 from random import randint from contextlib import contextmanager from . import pathutils def serialize(tag, headers=(), items=()): """Return a text corresponding to given collection ``tag``. The text may have the given ``headers`` and ``items`` added around the items if needed (ie. for calendars). """ items = sorted(items, key=lambda x: x.name) if tag == "VADDRESSBOOK": lines = [item.text for item in items] else: lines = ["BEGIN:%s" % tag] for part in (headers, items): if part: lines.append("\n".join(item.text for item in part)) lines.append("END:%s\n" % tag) return "\n".join(lines) def unfold(text): """Unfold multi-lines attributes. Read rfc5545-3.1 for info. """ return re.sub('\r\n( |\t)', '', text).splitlines() class Item(object): """Internal iCal item.""" def __init__(self, text, name=None): """Initialize object from ``text`` and different ``kwargs``.""" self.text = text self._name = name # We must synchronize the name in the text and in the object. # An item must have a name, determined in order by: # # - the ``name`` parameter # - the ``X-RADICALE-NAME`` iCal property (for Events, Todos, Journals) # - the ``UID`` iCal property (for Events, Todos, Journals) # - the ``TZID`` iCal property (for Timezones) if not self._name: for line in unfold(self.text): if line.startswith("X-RADICALE-NAME:"): self._name = line.replace("X-RADICALE-NAME:", "").strip() break elif line.startswith("TZID:"): self._name = line.replace("TZID:", "").strip() break elif line.startswith("UID:"): self._name = line.replace("UID:", "").strip() # Do not break, a ``X-RADICALE-NAME`` can appear next if self._name: # Remove brackets that may have been put by Outlook self._name = self._name.strip("{}") if "\nX-RADICALE-NAME:" in text: for line in unfold(self.text): if line.startswith("X-RADICALE-NAME:"): self.text = self.text.replace( line, "X-RADICALE-NAME:%s" % self._name) else: self.text = self.text.replace( "\nEND:", "\nX-RADICALE-NAME:%s\nEND:" % self._name) else: # workaround to get unicode on both python2 and 3 self._name = uuid4().hex.encode("ascii").decode("ascii") self.text = self.text.replace( "\nEND:", "\nX-RADICALE-NAME:%s\nEND:" % self._name) def __hash__(self): return hash(self.text) def __eq__(self, item): return isinstance(item, Item) and self.text == item.text @property def etag(self): """Item etag. Etag is mainly used to know if an item has changed. """ md5 = hashlib.md5() md5.update(self.text.encode("utf-8")) return '"%s"' % md5.hexdigest() @property def name(self): """Item name. Name is mainly used to give an URL to the item. """ return self._name class Header(Item): """Internal header class.""" class Timezone(Item): """Internal timezone class.""" tag = "VTIMEZONE" class Component(Item): """Internal main component of a collection.""" class Event(Component): """Internal event class.""" tag = "VEVENT" mimetype = "text/calendar" class Todo(Component): """Internal todo class.""" tag = "VTODO" # pylint: disable=W0511 mimetype = "text/calendar" class Journal(Component): """Internal journal class.""" tag = "VJOURNAL" mimetype = "text/calendar" class Card(Component): """Internal card class.""" tag = "VCARD" mimetype = "text/vcard" class Collection(object): """Internal collection item. This class must be overridden and replaced by a storage backend. """ def __init__(self, path, principal=False): """Initialize the collection. ``path`` must be the normalized relative path of the collection, using the slash as the folder delimiter, with no leading nor trailing slash. """ self.encoding = "utf-8" # path should already be sanitized self.path = pathutils.sanitize_path(path).strip("/") split_path = self.path.split("/") if principal and split_path and self.is_node(self.path): # Already existing principal collection self.owner = split_path[0] elif len(split_path) > 1: # URL with at least one folder self.owner = split_path[0] else: self.owner = None self.is_principal = principal self._items = None @classmethod def from_path(cls, path, depth="1", include_container=True): """Return a list of collections and items under the given ``path``. If ``depth`` is "0", only the actual object under ``path`` is returned. If ``depth`` is anything but "0", it is considered as "1" and direct children are included in the result. If ``include_container`` is ``True`` (the default), the containing object is included in the result. The ``path`` is relative. """ # path == None means wrong URL if path is None: return [] # path should already be sanitized sane_path = pathutils.sanitize_path(path).strip("/") attributes = sane_path.split("/") if not attributes: return [] # Try to guess if the path leads to a collection or an item if (cls.is_leaf("/".join(attributes[:-1])) or not path.endswith(("/", "/caldav", "/carddav"))): attributes.pop() result = [] path = "/".join(attributes) principal = len(attributes) <= 1 if cls.is_node(path): if depth == "0": result.append(cls(path, principal)) else: if include_container: result.append(cls(path, principal)) for child in cls.children(path): result.append(child) else: if depth == "0": result.append(cls(path)) else: collection = cls(path, principal) if include_container: result.append(collection) result.extend(collection.components) return result def save(self, text): """Save the text into the collection.""" raise NotImplementedError def delete(self): """Delete the collection.""" raise NotImplementedError @property def text(self): """Collection as plain text.""" raise NotImplementedError @classmethod def children(cls, path): """Yield the children of the collection at local ``path``.""" raise NotImplementedError @classmethod def is_node(cls, path): """Return ``True`` if relative ``path`` is a node. A node is a WebDAV collection whose members are other collections. """ raise NotImplementedError @classmethod def is_leaf(cls, path): """Return ``True`` if relative ``path`` is a leaf. A leaf is a WebDAV collection whose members are not collections. """ raise NotImplementedError @property def last_modified(self): """Get the last time the collection has been modified. The date is formatted according to rfc1123-5.2.14. """ raise NotImplementedError @property @contextmanager def props(self): """Get the collection properties.""" raise NotImplementedError @property def exists(self): """``True`` if the collection exists on the storage, else ``False``.""" return self.is_node(self.path) or self.is_leaf(self.path) @staticmethod def _parse(text, item_types, name=None): """Find items with type in ``item_types`` in ``text``. If ``name`` is given, give this name to new items in ``text``. Return a dict of items. """ item_tags = {} for item_type in item_types: item_tags[item_type.tag] = item_type items = {} lines = unfold(text) in_item = False for line in lines: if line.startswith("BEGIN:") and not in_item: item_tag = line.replace("BEGIN:", "").strip() if item_tag in item_tags: in_item = True item_lines = [] if in_item: item_lines.append(line) if line.startswith("END:%s" % item_tag): in_item = False item_type = item_tags[item_tag] item_text = "\n".join(item_lines) item_name = None if item_tag == "VTIMEZONE" else name item = item_type(item_text, item_name) if item.name in items: text = "\n".join((item.text, items[item.name].text)) items[item.name] = item_type(text, item.name) else: items[item.name] = item return items def append(self, name, text): """Append items from ``text`` to collection. If ``name`` is given, give this name to new items in ``text``. """ new_items = self._parse( text, (Timezone, Event, Todo, Journal, Card), name) for new_item in new_items.values(): if new_item.name not in self.items: self.items[new_item.name] = new_item self.write() def remove(self, name): """Remove object named ``name`` from collection.""" if name in self.items: del self.items[name] self.write() def replace(self, name, text): """Replace content by ``text`` in collection objet called ``name``.""" self.remove(name) self.append(name, text) def write(self): """Write collection with given parameters.""" text = serialize(self.tag, self.headers, self.items.values()) self.save(text) def set_mimetype(self, mimetype): """Set the mimetype of the collection.""" with self.props as props: if "tag" not in props: if mimetype == "text/vcard": props["tag"] = "VADDRESSBOOK" else: props["tag"] = "VCALENDAR" @property def tag(self): """Type of the collection.""" with self.props as props: if "tag" not in props: try: tag = open(self.path).readlines()[0][6:].rstrip() except IOError: if self.path.endswith((".vcf", "/carddav")): props["tag"] = "VADDRESSBOOK" else: props["tag"] = "VCALENDAR" else: if tag in ("VADDRESSBOOK", "VCARD"): props["tag"] = "VADDRESSBOOK" else: props["tag"] = "VCALENDAR" return props["tag"] @property def mimetype(self): """Mimetype of the collection.""" if self.tag == "VADDRESSBOOK": return "text/vcard" elif self.tag == "VCALENDAR": return "text/calendar" @property def resource_type(self): """Resource type of the collection.""" if self.tag == "VADDRESSBOOK": return "addressbook" elif self.tag == "VCALENDAR": return "calendar" @property def etag(self): """Etag from collection.""" md5 = hashlib.md5() md5.update(self.text.encode("utf-8")) return '"%s"' % md5.hexdigest() @property def name(self): """Collection name.""" with self.props as props: return props.get("D:displayname", self.path.split(os.path.sep)[-1]) @property def color(self): """Collection color.""" with self.props as props: if "ICAL:calendar-color" not in props: props["ICAL:calendar-color"] = "#%x" % randint(0, 255 ** 3 - 1) return props["ICAL:calendar-color"] @property def headers(self): """Find headers items in collection.""" header_lines = [] lines = unfold(self.text)[1:] for line in lines: if line.startswith(("BEGIN:", "END:")): break header_lines.append(Header(line)) return header_lines or ( Header("PRODID:-//Radicale//NONSGML Radicale Server//EN"), Header("VERSION:%s" % self.version)) @property def items(self): """Get list of all items in collection.""" if self._items is None: self._items = self._parse( self.text, (Event, Todo, Journal, Card, Timezone)) return self._items @property def timezones(self): """Get list of all timezones in collection.""" return [ item for item in self.items.values() if item.tag == Timezone.tag] @property def components(self): """Get list of all components in collection.""" tags = [item_type.tag for item_type in (Event, Todo, Journal, Card)] return [item for item in self.items.values() if item.tag in tags] @property def owner_url(self): """Get the collection URL according to its owner.""" return "/%s/" % self.owner if self.owner else None @property def url(self): """Get the standard collection URL.""" return "%s/" % self.path @property def version(self): """Get the version of the collection type.""" return "3.0" if self.tag == "VADDRESSBOOK" else "2.0" Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/log.py000066400000000000000000000042241264614074700227560ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2011-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale logging module. Manage logging from a configuration file. For more information, see: http://docs.python.org/library/logging.config.html """ import os import sys import logging import logging.config import signal from . import config LOGGER = logging.getLogger() def configure_from_file(filename, debug): logging.config.fileConfig(filename) if debug: LOGGER.setLevel(logging.DEBUG) for handler in LOGGER.handlers: handler.setLevel(logging.DEBUG) def start(): """Start the logging according to the configuration.""" filename = os.path.expanduser(config.get("logging", "config")) debug = config.getboolean("logging", "debug") if os.path.exists(filename): # Configuration taken from file configure_from_file(filename, debug) # Reload config on SIGHUP (UNIX only) if hasattr(signal, 'SIGHUP'): def handler(signum, frame): configure_from_file(filename, debug) signal.signal(signal.SIGHUP, handler) else: # Default configuration, standard output handler = logging.StreamHandler(sys.stdout) handler.setFormatter(logging.Formatter("%(message)s")) LOGGER.addHandler(handler) if debug: LOGGER.setLevel(logging.DEBUG) LOGGER.debug( "Logging configuration file '%s' not found, using stdout." % filename) Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/pathutils.py000066400000000000000000000052221264614074700242110ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Helper functions for working with paths. """ import os import posixpath from . import log def sanitize_path(path): """Make path absolute with leading slash to prevent access to other data. Preserve a potential trailing slash. """ trailing_slash = "/" if path.endswith("/") else "" path = posixpath.normpath(path) new_path = "/" for part in path.split("/"): if not part or part in (".", ".."): continue new_path = posixpath.join(new_path, part) trailing_slash = "" if new_path.endswith("/") else trailing_slash return new_path + trailing_slash def is_safe_path_component(path): """Check if path is a single component of a POSIX path. Check that the path is safe to join too. """ if not path: return False head, _ = posixpath.split(path) if head: return False if path in (".", ".."): return False return True def is_safe_filesystem_path_component(path): """Check if path is a single component of a filesystem path. Check that the path is safe to join too. """ if not path: return False drive, _ = os.path.splitdrive(path) if drive: return False head, _ = os.path.split(path) if head: return False if path in (os.curdir, os.pardir): return False return True def path_to_filesystem(path, base_folder): """Convert path to a local filesystem path relative to base_folder. Conversion is done in a secure manner, or raises ValueError. """ sane_path = sanitize_path(path).strip("/") safe_path = base_folder if not sane_path: return safe_path for part in sane_path.split("/"): if not is_safe_filesystem_path_component(part): log.LOGGER.debug( "Can't translate path safely to filesystem: %s", path) raise ValueError("Unsafe path") safe_path = os.path.join(safe_path, part) return safe_path Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/rights/000077500000000000000000000000001264614074700231215ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/rights/__init__.py000066400000000000000000000030741264614074700252360ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Rights backends. This module loads the rights backend, according to the rights configuration. """ import sys from .. import config def load(): """Load list of available storage managers.""" storage_type = config.get("rights", "type") if storage_type == "custom": rights_module = config.get("rights", "custom_handler") __import__(rights_module) module = sys.modules[rights_module] else: root_module = __import__("rights.regex", globals=globals(), level=2) module = root_module.regex sys.modules[__name__].authorized = module.authorized return module def authorized(user, collection, right): """Check that an user has rights on a collection. This method is overriden when the appropriate rights backend is loaded. """ raise NotImplementedError() Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/rights/regex.py000066400000000000000000000102251264614074700246050ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Rights management. Rights are based on a regex-based file whose name is specified in the config (section "right", key "file"). Authentication login is matched against the "user" key, and collection's path is matched against the "collection" key. You can use Python's ConfigParser interpolation values %(login)s and %(path)s. You can also get groups from the user regex in the collection with {0}, {1}, etc. For example, for the "user" key, ".+" means "authenticated user" and ".*" means "anybody" (including anonymous users). Section names are only used for naming the rule. Leading or ending slashes are trimmed from collection's path. """ import re import sys import os.path from .. import config, log # Manage Python2/3 different modules if sys.version_info[0] == 2: from ConfigParser import ConfigParser from StringIO import StringIO else: from configparser import ConfigParser from io import StringIO DEFINED_RIGHTS = { "authenticated": """ [rw] user:.+ collection:.* permission:rw """, "owner_write": """ [w] user:.+ collection:^%(login)s(/.*)?$ permission:rw [r] user:.+ collection:.* permission:r """, "owner_only": """ [rw] user:.+ collection:^%(login)s(/.*)?$ permission:rw """} def _read_from_sections(user, collection_url, permission): """Get regex sections.""" filename = os.path.expanduser(config.get("rights", "file")) rights_type = config.get("rights", "type").lower() # Prevent "regex injection" user_escaped = re.escape(user) collection_url_escaped = re.escape(collection_url) regex = ConfigParser({"login": user_escaped, "path": collection_url_escaped}) if rights_type in DEFINED_RIGHTS: log.LOGGER.debug("Rights type '%s'" % rights_type) regex.readfp(StringIO(DEFINED_RIGHTS[rights_type])) elif rights_type == "from_file": log.LOGGER.debug("Reading rights from file %s" % filename) if not regex.read(filename): log.LOGGER.error("File '%s' not found for rights" % filename) return False else: log.LOGGER.error("Unknown rights type '%s'" % rights_type) return False for section in regex.sections(): re_user = regex.get(section, "user") re_collection = regex.get(section, "collection") log.LOGGER.debug( "Test if '%s:%s' matches against '%s:%s' from section '%s'" % ( user, collection_url, re_user, re_collection, section)) user_match = re.match(re_user, user) if user_match: re_collection = re_collection.format(*user_match.groups()) if re.match(re_collection, collection_url): log.LOGGER.debug("Section '%s' matches" % section) return permission in regex.get(section, "permission") else: log.LOGGER.debug("Section '%s' does not match" % section) return False def authorized(user, collection, permission): """Check if the user is allowed to read or write the collection. If the user is empty, check for anonymous rights. """ collection_url = collection.url.rstrip("/") or "/" if collection_url in (".well-known/carddav", ".well-known/caldav"): return permission == "r" rights_type = config.get("rights", "type").lower() return ( rights_type == "none" or _read_from_sections(user or "", collection_url, permission)) Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/storage/000077500000000000000000000000001264614074700232655ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/storage/__init__.py000066400000000000000000000026121264614074700253770ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Storage backends. This module loads the storage backend, according to the storage configuration. """ import sys from .. import config, ical def load(): """Load list of available storage managers.""" storage_type = config.get("storage", "type") if storage_type == "custom": storage_module = config.get("storage", "custom_handler") __import__(storage_module) module = sys.modules[storage_module] else: root_module = __import__( "storage.%s" % storage_type, globals=globals(), level=2) module = getattr(root_module, storage_type) ical.Collection = module.Collection return module Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/storage/database.py000066400000000000000000000206461264614074700254130ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ SQLAlchemy storage backend. """ import time from datetime import datetime from contextlib import contextmanager from sqlalchemy import create_engine, Column, Unicode, Integer, ForeignKey from sqlalchemy import func from sqlalchemy.orm import sessionmaker, relationship from sqlalchemy.ext.declarative import declarative_base from .. import config, ical # These are classes, not constants # pylint: disable=C0103 Base = declarative_base() Session = sessionmaker() Session.configure(bind=create_engine(config.get("storage", "database_url"))) # pylint: enable=C0103 class DBCollection(Base): """Table of collections.""" __tablename__ = "collection" path = Column(Unicode, primary_key=True) parent_path = Column(Unicode, ForeignKey("collection.path")) parent = relationship( "DBCollection", backref="children", remote_side=[path]) class DBItem(Base): """Table of collection's items.""" __tablename__ = "item" name = Column(Unicode, primary_key=True) tag = Column(Unicode) collection_path = Column(Unicode, ForeignKey("collection.path")) collection = relationship("DBCollection", backref="items") class DBHeader(Base): """Table of item's headers.""" __tablename__ = "header" name = Column(Unicode, primary_key=True) value = Column(Unicode) collection_path = Column( Unicode, ForeignKey("collection.path"), primary_key=True) collection = relationship("DBCollection", backref="headers") class DBLine(Base): """Table of item's lines.""" __tablename__ = "line" name = Column(Unicode) value = Column(Unicode) item_name = Column(Unicode, ForeignKey("item.name")) timestamp = Column( Integer, default=lambda: time.time() * 10 ** 6, primary_key=True) item = relationship("DBItem", backref="lines", order_by=timestamp) class DBProperty(Base): """Table of collection's properties.""" __tablename__ = "property" name = Column(Unicode, primary_key=True) value = Column(Unicode) collection_path = Column( Unicode, ForeignKey("collection.path"), primary_key=True) collection = relationship( "DBCollection", backref="properties", cascade="delete") class Collection(ical.Collection): """Collection stored in a database.""" def __init__(self, path, principal=False): self.session = Session() super(Collection, self).__init__(path, principal) def __del__(self): self.session.commit() def _query(self, item_types): """Get collection's items matching ``item_types``.""" item_objects = [] for item_type in item_types: items = ( self.session.query(DBItem) .filter_by(collection_path=self.path, tag=item_type.tag) .order_by(DBItem.name).all()) for item in items: text = "\n".join( "%s:%s" % (line.name, line.value) for line in item.lines) item_objects.append(item_type(text, item.name)) return item_objects @property def _modification_time(self): """Collection's last modification time.""" timestamp = ( self.session.query(func.max(DBLine.timestamp)) .join(DBItem).filter_by(collection_path=self.path).first()[0]) if timestamp: return datetime.fromtimestamp(float(timestamp) / 10 ** 6) else: return datetime.now() @property def _db_collection(self): """Collection's object mapped to the table line.""" return self.session.query(DBCollection).get(self.path) def write(self): if self._db_collection: for item in self._db_collection.items: for line in item.lines: self.session.delete(line) self.session.delete(item) for header in self._db_collection.headers: self.session.delete(header) else: db_collection = DBCollection() db_collection.path = self.path db_collection.parent_path = "/".join(self.path.split("/")[:-1]) self.session.add(db_collection) for header in self.headers: db_header = DBHeader() db_header.name, db_header.value = header.text.split(":", 1) db_header.collection_path = self.path self.session.add(db_header) for item in self.items.values(): db_item = DBItem() db_item.name = item.name db_item.tag = item.tag db_item.collection_path = self.path self.session.add(db_item) for line in ical.unfold(item.text): db_line = DBLine() db_line.name, db_line.value = line.split(":", 1) db_line.item_name = item.name self.session.add(db_line) def delete(self): self.session.delete(self._db_collection) @property def text(self): return ical.serialize(self.tag, self.headers, self.components) @property def etag(self): return '"%s"' % hash(self._modification_time) @property def headers(self): headers = ( self.session.query(DBHeader) .filter_by(collection_path=self.path) .order_by(DBHeader.name).all()) return [ ical.Header("%s:%s" % (header.name, header.value)) for header in headers] @classmethod def children(cls, path): session = Session() children = ( session.query(DBCollection) .filter_by(parent_path=path or "").all()) collections = [cls(child.path) for child in children] session.close() return collections @classmethod def is_node(cls, path): if not path: return True session = Session() result = ( session.query(DBCollection) .filter_by(parent_path=path or "").count() > 0) session.close() return result @classmethod def is_leaf(cls, path): if not path: return False session = Session() result = ( session.query(DBItem) .filter_by(collection_path=path or "").count() > 0) session.close() return result @property def last_modified(self): return time.strftime( "%a, %d %b %Y %H:%M:%S +0000", self._modification_time.timetuple()) @property @contextmanager def props(self): # On enter properties = {} db_properties = ( self.session.query(DBProperty) .filter_by(collection_path=self.path).all()) for prop in db_properties: properties[prop.name] = prop.value old_properties = properties.copy() yield properties # On exit if old_properties != properties: for prop in db_properties: self.session.delete(prop) for name, value in properties.items(): prop = DBProperty(name=name, value=value or '', collection_path=self.path) self.session.add(prop) @property def components(self): return self._query((ical.Event, ical.Todo, ical.Journal, ical.Card)) @property def events(self): return self._query((ical.Event,)) @property def todos(self): return self._query((ical.Todo,)) @property def journals(self): return self._query((ical.Journal,)) @property def timezones(self): return self._query((ical.Timezone,)) @property def cards(self): return self._query((ical.Card,)) def save(self): """Save the text into the collection. This method is not used for databases. """ Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/storage/filesystem.py000066400000000000000000000112031264614074700260200ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012-2015 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Filesystem storage backend. """ import codecs import os import posixpath import json import time import sys from contextlib import contextmanager from .. import config, ical, log, pathutils FOLDER = os.path.expanduser(config.get("storage", "filesystem_folder")) FILESYSTEM_ENCODING = sys.getfilesystemencoding() try: from dulwich.repo import Repo GIT_REPOSITORY = Repo(FOLDER) except: GIT_REPOSITORY = None # This function overrides the builtin ``open`` function for this module # pylint: disable=W0622 @contextmanager def open(path, mode="r"): """Open a file at ``path`` with encoding set in the configuration.""" # On enter abs_path = os.path.join(FOLDER, path.replace("/", os.sep)) with codecs.open(abs_path, mode, config.get("encoding", "stock")) as fd: yield fd # On exit if GIT_REPOSITORY and mode == "w": path = os.path.relpath(abs_path, FOLDER) GIT_REPOSITORY.stage([path]) committer = config.get("git", "committer") GIT_REPOSITORY.do_commit( path.encode("utf-8"), committer=committer.encode("utf-8")) # pylint: enable=W0622 class Collection(ical.Collection): """Collection stored in a flat ical file.""" @property def _filesystem_path(self): """Absolute path of the file at local ``path``.""" return pathutils.path_to_filesystem(self.path, FOLDER) @property def _props_path(self): """Absolute path of the file storing the collection properties.""" return self._filesystem_path + ".props" def _create_dirs(self): """Create folder storing the collection if absent.""" if not os.path.exists(os.path.dirname(self._filesystem_path)): os.makedirs(os.path.dirname(self._filesystem_path)) def save(self, text): self._create_dirs() with open(self._filesystem_path, "w") as fd: fd.write(text) def delete(self): os.remove(self._filesystem_path) os.remove(self._props_path) @property def text(self): try: with open(self._filesystem_path) as fd: return fd.read() except IOError: return "" @classmethod def children(cls, path): filesystem_path = pathutils.path_to_filesystem(path, FOLDER) _, directories, files = next(os.walk(filesystem_path)) for filename in directories + files: # make sure that the local filename can be translated # into an internal path if not pathutils.is_safe_path_component(filename): log.LOGGER.debug("Skipping unsupported filename: %s", filename) continue rel_filename = posixpath.join(path, filename) if cls.is_node(rel_filename) or cls.is_leaf(rel_filename): yield cls(rel_filename) @classmethod def is_node(cls, path): filesystem_path = pathutils.path_to_filesystem(path, FOLDER) return os.path.isdir(filesystem_path) @classmethod def is_leaf(cls, path): filesystem_path = pathutils.path_to_filesystem(path, FOLDER) return ( os.path.isfile(filesystem_path) and not filesystem_path.endswith(".props")) @property def last_modified(self): modification_time = time.gmtime( os.path.getmtime(self._filesystem_path)) return time.strftime("%a, %d %b %Y %H:%M:%S +0000", modification_time) @property @contextmanager def props(self): # On enter properties = {} if os.path.exists(self._props_path): with open(self._props_path) as prop_file: properties.update(json.load(prop_file)) old_properties = properties.copy() yield properties # On exit self._create_dirs() if old_properties != properties: with open(self._props_path, "w") as prop_file: json.dump(properties, prop_file) Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/storage/multifilesystem.py000066400000000000000000000105161264614074700271010ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2014 Jean-Marc Martins # Copyright © 2014-2015 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Multi files per calendar filesystem storage backend. """ import os import shutil import time import sys from . import filesystem from .. import ical from .. import log from .. import pathutils class Collection(filesystem.Collection): """Collection stored in several files per calendar.""" def _create_dirs(self): if not os.path.exists(self._filesystem_path): os.makedirs(self._filesystem_path) @property def headers(self): return ( ical.Header("PRODID:-//Radicale//NONSGML Radicale Server//EN"), ical.Header("VERSION:%s" % self.version)) def write(self): self._create_dirs() for component in self.components: text = ical.serialize( self.tag, self.headers, [component] + self.timezones) name = ( component.name if sys.version_info[0] >= 3 else component.name.encode(filesystem.FILESYSTEM_ENCODING)) if not pathutils.is_safe_filesystem_path_component(name): log.LOGGER.debug( "Can't tranlate name safely to filesystem, " "skipping component: %s", name) continue filesystem_path = os.path.join(self._filesystem_path, name) with filesystem.open(filesystem_path, "w") as fd: fd.write(text) def delete(self): shutil.rmtree(self._filesystem_path) os.remove(self._props_path) def remove(self, name): if not pathutils.is_safe_filesystem_path_component(name): log.LOGGER.debug( "Can't tranlate name safely to filesystem, " "skipping component: %s", name) return if name in self.items: del self.items[name] filesystem_path = os.path.join(self._filesystem_path, name) if os.path.exists(filesystem_path): os.remove(filesystem_path) @property def text(self): components = ( ical.Timezone, ical.Event, ical.Todo, ical.Journal, ical.Card) items = {} try: filenames = os.listdir(self._filesystem_path) except (OSError, IOError) as e: log.LOGGER.info( 'Error while reading collection %r: %r' % ( self._filesystem_path, e)) return "" for filename in filenames: path = os.path.join(self._filesystem_path, filename) try: with filesystem.open(path) as fd: items.update(self._parse(fd.read(), components)) except (OSError, IOError) as e: log.LOGGER.warning( 'Error while reading item %r: %r' % (path, e)) return ical.serialize( self.tag, self.headers, sorted(items.values(), key=lambda x: x.name)) @classmethod def is_node(cls, path): filesystem_path = pathutils.path_to_filesystem(path, filesystem.FOLDER) return ( os.path.isdir(filesystem_path) and not os.path.exists(filesystem_path + ".props")) @classmethod def is_leaf(cls, path): filesystem_path = pathutils.path_to_filesystem(path, filesystem.FOLDER) return ( os.path.isdir(filesystem_path) and os.path.exists(path + ".props")) @property def last_modified(self): last = max([ os.path.getmtime(os.path.join(self._filesystem_path, filename)) for filename in os.listdir(self._filesystem_path)] or [0]) return time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(last)) Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/radicale/xmlutils.py000066400000000000000000000500211264614074700240520ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2015 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ XML and iCal requests manager. Note that all these functions need to receive unicode objects for full iCal requests (PUT) and string objects with charset correctly defined in them for XML requests (all but PUT). """ try: from collections import OrderedDict except ImportError: # Python 2.6 has no OrderedDict, use a dict instead OrderedDict = dict # pylint: disable=C0103 # Manage Python2/3 different modules # pylint: disable=F0401,E0611 try: from urllib.parse import unquote, urlparse except ImportError: from urllib import unquote from urlparse import urlparse # pylint: enable=F0401,E0611 import re import xml.etree.ElementTree as ET from . import client, config, ical NAMESPACES = { "C": "urn:ietf:params:xml:ns:caldav", "CR": "urn:ietf:params:xml:ns:carddav", "D": "DAV:", "CS": "http://calendarserver.org/ns/", "ICAL": "http://apple.com/ns/ical/", "ME": "http://me.com/_namespace/"} NAMESPACES_REV = {} for short, url in NAMESPACES.items(): NAMESPACES_REV[url] = short if hasattr(ET, "register_namespace"): # Register namespaces cleanly with Python 2.7+ and 3.2+ ... ET.register_namespace("" if short == "D" else short, url) else: # ... and badly with Python 2.6 and 3.1 ET._namespace_map[url] = short # pylint: disable=W0212 CLARK_TAG_REGEX = re.compile(r""" { # { (?P[^}]*) # namespace URL } # } (?P.*) # short tag name """, re.VERBOSE) def _pretty_xml(element, level=0): """Indent an ElementTree ``element`` and its children.""" i = "\n" + level * " " if len(element): if not element.text or not element.text.strip(): element.text = i + " " if not element.tail or not element.tail.strip(): element.tail = i for sub_element in element: _pretty_xml(sub_element, level + 1) # ``sub_element`` is always defined as len(element) > 0 # pylint: disable=W0631 if not sub_element.tail or not sub_element.tail.strip(): sub_element.tail = i # pylint: enable=W0631 else: if level and (not element.tail or not element.tail.strip()): element.tail = i if not level: output_encoding = config.get("encoding", "request") return ('\n' + ET.tostring( element, "utf-8").decode("utf-8")).encode(output_encoding) def _tag(short_name, local): """Get XML Clark notation {uri(``short_name``)}``local``.""" return "{%s}%s" % (NAMESPACES[short_name], local) def _tag_from_clark(name): """Get a human-readable variant of the XML Clark notation tag ``name``. For a given name using the XML Clark notation, return a human-readable variant of the tag name for known namespaces. Otherwise, return the name as is. """ match = CLARK_TAG_REGEX.match(name) if match and match.group("namespace") in NAMESPACES_REV: args = { "ns": NAMESPACES_REV[match.group("namespace")], "tag": match.group("tag")} return "%(ns)s:%(tag)s" % args return name def _response(code): """Return full W3C names from HTTP status codes.""" return "HTTP/1.1 %i %s" % (code, client.responses[code]) def _href(href): """Return prefixed href.""" return "%s%s" % (config.get("server", "base_prefix"), href.lstrip("/")) def name_from_path(path, collection): """Return Radicale item name from ``path``.""" collection_parts = collection.path.strip("/").split("/") path_parts = path.strip("/").split("/") if (len(path_parts) - len(collection_parts)): return path_parts[-1] def props_from_request(root, actions=("set", "remove")): """Return a list of properties as a dictionary.""" result = OrderedDict() if not hasattr(root, "tag"): root = ET.fromstring(root.encode("utf8")) for action in actions: action_element = root.find(_tag("D", action)) if action_element is not None: break else: action_element = root prop_element = action_element.find(_tag("D", "prop")) if prop_element is not None: for prop in prop_element: if prop.tag == _tag("D", "resourcetype"): for resource_type in prop: if resource_type.tag == _tag("C", "calendar"): result["tag"] = "VCALENDAR" break elif resource_type.tag == _tag("CR", "addressbook"): result["tag"] = "VADDRESSBOOK" break elif prop.tag == _tag("C", "supported-calendar-component-set"): result[_tag_from_clark(prop.tag)] = ",".join( supported_comp.attrib["name"] for supported_comp in prop if supported_comp.tag == _tag("C", "comp")) else: result[_tag_from_clark(prop.tag)] = prop.text return result def delete(path, collection): """Read and answer DELETE requests. Read rfc4918-9.6 for info. """ # Reading request if collection.path == path.strip("/"): # Delete the whole collection collection.delete() else: # Remove an item from the collection collection.remove(name_from_path(path, collection)) # Writing answer multistatus = ET.Element(_tag("D", "multistatus")) response = ET.Element(_tag("D", "response")) multistatus.append(response) href = ET.Element(_tag("D", "href")) href.text = _href(path) response.append(href) status = ET.Element(_tag("D", "status")) status.text = _response(200) response.append(status) return _pretty_xml(multistatus) def propfind(path, xml_request, collections, user=None): """Read and answer PROPFIND requests. Read rfc4918-9.1 for info. The collections parameter is a list of collections that are to be included in the output. Rights checking has to be done by the caller. """ # Reading request if xml_request: root = ET.fromstring(xml_request.encode("utf8")) props = [prop.tag for prop in root.find(_tag("D", "prop"))] else: props = [_tag("D", "getcontenttype"), _tag("D", "resourcetype"), _tag("D", "displayname"), _tag("D", "owner"), _tag("D", "getetag"), _tag("ICAL", "calendar-color"), _tag("CS", "getctag")] # Writing answer multistatus = ET.Element(_tag("D", "multistatus")) for collection in collections: response = _propfind_response(path, collection, props, user) multistatus.append(response) return _pretty_xml(multistatus) def _propfind_response(path, item, props, user): """Build and return a PROPFIND response.""" is_collection = isinstance(item, ical.Collection) if is_collection: with item.props as properties: collection_props = properties response = ET.Element(_tag("D", "response")) href = ET.Element(_tag("D", "href")) uri = item.url if is_collection else "%s/%s" % (path, item.name) href.text = _href(uri.replace("//", "/")) response.append(href) propstat404 = ET.Element(_tag("D", "propstat")) propstat200 = ET.Element(_tag("D", "propstat")) response.append(propstat200) prop200 = ET.Element(_tag("D", "prop")) propstat200.append(prop200) prop404 = ET.Element(_tag("D", "prop")) propstat404.append(prop404) for tag in props: element = ET.Element(tag) is404 = False if tag == _tag("D", "getetag"): element.text = item.etag elif tag == _tag("D", "principal-URL"): tag = ET.Element(_tag("D", "href")) tag.text = _href(path) element.append(tag) elif tag in (_tag("D", "principal-collection-set"), _tag("C", "calendar-user-address-set"), _tag("CR", "addressbook-home-set"), _tag("C", "calendar-home-set")): tag = ET.Element(_tag("D", "href")) tag.text = _href(path) element.append(tag) elif tag == _tag("C", "supported-calendar-component-set"): # This is not a Todo # pylint: disable=W0511 human_tag = _tag_from_clark(tag) if is_collection and human_tag in collection_props: # TODO: what do we have to do if it's not a collection? components = collection_props[human_tag].split(",") else: components = ("VTODO", "VEVENT", "VJOURNAL") for component in components: comp = ET.Element(_tag("C", "comp")) comp.set("name", component) element.append(comp) # pylint: enable=W0511 elif tag == _tag("D", "current-user-principal") and user: tag = ET.Element(_tag("D", "href")) tag.text = _href("/%s/" % user) element.append(tag) elif tag == _tag("D", "current-user-privilege-set"): privilege = ET.Element(_tag("D", "privilege")) privilege.append(ET.Element(_tag("D", "all"))) privilege.append(ET.Element(_tag("D", "read"))) privilege.append(ET.Element(_tag("D", "write"))) privilege.append(ET.Element(_tag("D", "write-properties"))) privilege.append(ET.Element(_tag("D", "write-content"))) element.append(privilege) elif tag == _tag("D", "supported-report-set"): for report_name in ( "principal-property-search", "sync-collection", "expand-property", "principal-search-property-set"): supported = ET.Element(_tag("D", "supported-report")) report_tag = ET.Element(_tag("D", "report")) report_tag.text = report_name supported.append(report_tag) element.append(supported) elif is_collection: if tag == _tag("D", "getcontenttype"): element.text = item.mimetype elif tag == _tag("D", "resourcetype"): if item.is_principal: tag = ET.Element(_tag("D", "principal")) element.append(tag) if item.is_leaf(item.path) or ( not item.exists and item.resource_type): # 2nd case happens when the collection is not stored yet, # but the resource type is guessed if item.resource_type == "addressbook": tag = ET.Element(_tag("CR", item.resource_type)) else: tag = ET.Element(_tag("C", item.resource_type)) element.append(tag) tag = ET.Element(_tag("D", "collection")) element.append(tag) elif tag == _tag("D", "owner") and item.owner_url: element.text = item.owner_url elif tag == _tag("CS", "getctag"): element.text = item.etag elif tag == _tag("C", "calendar-timezone"): element.text = ical.serialize( item.tag, item.headers, item.timezones) elif tag == _tag("D", "displayname"): element.text = item.name elif tag == _tag("ICAL", "calendar-color"): element.text = item.color else: human_tag = _tag_from_clark(tag) if human_tag in collection_props: element.text = collection_props[human_tag] else: is404 = True # Not for collections elif tag == _tag("D", "getcontenttype"): element.text = "%s; component=%s" % ( item.mimetype, item.tag.lower()) elif tag == _tag("D", "resourcetype"): # resourcetype must be returned empty for non-collection elements pass else: is404 = True if is404: prop404.append(element) else: prop200.append(element) status200 = ET.Element(_tag("D", "status")) status200.text = _response(200) propstat200.append(status200) status404 = ET.Element(_tag("D", "status")) status404.text = _response(404) propstat404.append(status404) if len(prop404): response.append(propstat404) return response def _add_propstat_to(element, tag, status_number): """Add a PROPSTAT response structure to an element. The PROPSTAT answer structure is defined in rfc4918-9.1. It is added to the given ``element``, for the following ``tag`` with the given ``status_number``. """ propstat = ET.Element(_tag("D", "propstat")) element.append(propstat) prop = ET.Element(_tag("D", "prop")) propstat.append(prop) if "{" in tag: clark_tag = tag else: clark_tag = _tag(*tag.split(":", 1)) prop_tag = ET.Element(clark_tag) prop.append(prop_tag) status = ET.Element(_tag("D", "status")) status.text = _response(status_number) propstat.append(status) def proppatch(path, xml_request, collection): """Read and answer PROPPATCH requests. Read rfc4918-9.2 for info. """ # Reading request root = ET.fromstring(xml_request.encode("utf8")) props_to_set = props_from_request(root, actions=("set",)) props_to_remove = props_from_request(root, actions=("remove",)) # Writing answer multistatus = ET.Element(_tag("D", "multistatus")) response = ET.Element(_tag("D", "response")) multistatus.append(response) href = ET.Element(_tag("D", "href")) href.text = _href(path) response.append(href) with collection.props as collection_props: for short_name, value in props_to_set.items(): if short_name.split(":")[-1] == "calendar-timezone": collection.replace(None, value) collection_props[short_name] = value _add_propstat_to(response, short_name, 200) for short_name in props_to_remove: try: del collection_props[short_name] except KeyError: _add_propstat_to(response, short_name, 412) else: _add_propstat_to(response, short_name, 200) return _pretty_xml(multistatus) def put(path, ical_request, collection): """Read PUT requests.""" name = name_from_path(path, collection) if name in collection.items: # PUT is modifying an existing item collection.replace(name, ical_request) elif name: # PUT is adding a new item collection.append(name, ical_request) else: # PUT is replacing the whole collection collection.save(ical_request) def report(path, xml_request, collection): """Read and answer REPORT requests. Read rfc3253-3.6 for info. """ # Reading request root = ET.fromstring(xml_request.encode("utf8")) prop_element = root.find(_tag("D", "prop")) props = ( [prop.tag for prop in prop_element] if prop_element is not None else []) if collection: if root.tag in (_tag("C", "calendar-multiget"), _tag("CR", "addressbook-multiget")): # Read rfc4791-7.9 for info base_prefix = config.get("server", "base_prefix") hreferences = set() for href_element in root.findall(_tag("D", "href")): href_path = unquote(urlparse(href_element.text).path) if href_path.startswith(base_prefix): hreferences.add(href_path[len(base_prefix):]) else: hreferences = (path,) # TODO: handle other filters # TODO: handle the nested comp-filters correctly # Read rfc4791-9.7.1 for info tag_filters = set( element.get("name") for element in root.findall(".//%s" % _tag("C", "comp-filter"))) tag_filters.discard('VCALENDAR') else: hreferences = () tag_filters = None # Writing answer multistatus = ET.Element(_tag("D", "multistatus")) collection_tag = collection.tag collection_headers = collection.headers collection_timezones = collection.timezones for hreference in hreferences: # Check if the reference is an item or a collection name = name_from_path(hreference, collection) if name: # Reference is an item path = "/".join(hreference.split("/")[:-1]) + "/" try: items = [collection.items[name]] except KeyError: multistatus.append( _item_response(hreference, found_item=False)) continue else: # Reference is a collection path = hreference items = collection.components for item in items: href = _href("%s/%s" % (path.rstrip("/"), item.name)) if tag_filters and item.tag not in tag_filters: continue found_props = [] not_found_props = [] for tag in props: element = ET.Element(tag) if tag == _tag("D", "getetag"): element.text = item.etag found_props.append(element) elif tag == _tag("D", "getcontenttype"): element.text = "%s; component=%s" % ( item.mimetype, item.tag.lower()) found_props.append(element) elif tag in (_tag("C", "calendar-data"), _tag("CR", "address-data")): if isinstance(item, ical.Component): element.text = ical.serialize( collection_tag, collection_headers, collection_timezones + [item]) found_props.append(element) else: not_found_props.append(element) multistatus.append(_item_response( href, found_props=found_props, not_found_props=not_found_props, found_item=True)) return _pretty_xml(multistatus) def _item_response(href, found_props=(), not_found_props=(), found_item=True): response = ET.Element(_tag("D", "response")) href_tag = ET.Element(_tag("D", "href")) href_tag.text = href response.append(href_tag) if found_item: if found_props: propstat = ET.Element(_tag("D", "propstat")) status = ET.Element(_tag("D", "status")) status.text = _response(200) prop = ET.Element(_tag("D", "prop")) for p in found_props: prop.append(p) propstat.append(prop) propstat.append(status) response.append(propstat) if not_found_props: propstat = ET.Element(_tag("D", "propstat")) status = ET.Element(_tag("D", "status")) status.text = _response(404) prop = ET.Element(_tag("D", "prop")) for p in not_found_props: prop.append(p) propstat.append(prop) propstat.append(status) response.append(propstat) else: status = ET.Element(_tag("D", "status")) status.text = _response(404) response.append(status) return response Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/rights000066400000000000000000000016251264614074700213040ustar00rootroot00000000000000# -*- mode: conf -*- # vim:ft=cfg # Rights management file for Radicale - A simple calendar server # # Default path for this kind of files is ~/.config/radicale/rights # This means all users starting with "admin" may read any collection [admin] user: ^admin.*$ collection: .* permission: r # This means all users may read and write any collection starting with public. # We do so by just not testing against the user string. [public] user: .* collection: ^public(/.+)?$ permission: rw # A little more complex: give read access to users from a domain for all # collections of all the users (ie. user@domain.tld can read domain/*). [domain-wide-access] user: ^.+@(.+)\..+$ collection: ^{0}/.+$ permission: r # Allow authenticated user to read all collections [allow-everyone-read] user: .+ collection: .* permission: r # Give write access to owners [owner-write] user: .+ collection: ^%(login)s/.*$ permission: w Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/schema.sql000066400000000000000000000017351264614074700220440ustar00rootroot00000000000000-- This is the database schema for PostgreSQL and MySQL and SQLite. create table collection ( path varchar(200) not null, parent_path varchar(200) references collection (path), primary key (path)); create table item ( name varchar(200) not null, tag text not null, collection_path varchar(200) references collection (path), primary key (name)); create table header ( name varchar(200) not null, value text not null, collection_path varchar(200) references collection (path), primary key (name, collection_path)); create table line ( name text not null, value text not null, item_name varchar(200) references item (name), timestamp bigint not null, primary key (timestamp)); create table property ( name varchar(200) not null, value text not null, collection_path varchar(200) references collection (path), primary key (name, collection_path)); Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/setup.py000077500000000000000000000057641264614074700216060ustar00rootroot00000000000000#!/usr/bin/python # -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2009-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale CalDAV and CardDAV server ================================== The Radicale Project is a CalDAV (calendar) and CardDAV (contact) server. It aims to be a light solution, easy to use, easy to install, easy to configure. As a consequence, it requires few software dependances and is pre-configured to work out-of-the-box. The Radicale Project runs on most of the UNIX-like platforms (Linux, BSD, MacOS X) and Windows. It is known to work with Evolution, Lightning, iPhone and Android clients. It is free and open-source software, released under GPL version 3. For further information, please visit the `Radicale Website `_. """ from setuptools import setup import radicale # When the version is updated, ``radicale.VERSION`` must be modified. # A new section in the ``NEWS`` file must be added too. setup( name="Radicale", version=radicale.VERSION, description="CalDAV and CardDAV Server", long_description=__doc__, author="Guillaume Ayoub", author_email="guillaume.ayoub@kozea.fr", url="http://www.radicale.org/", download_url=("http://pypi.python.org/packages/source/R/Radicale/" "Radicale-%s.tar.gz" % radicale.VERSION), license="GNU GPL v3", platforms="Any", packages=[ "radicale", "radicale.auth", "radicale.storage", "radicale.rights"], provides=["radicale"], scripts=["bin/radicale"], keywords=["calendar", "addressbook", "CalDAV", "CardDAV"], classifiers=[ "Development Status :: 5 - Production/Stable", "Environment :: Console", "Environment :: Web Environment", "Intended Audience :: End Users/Desktop", "Intended Audience :: Information Technology", "License :: OSI Approved :: GNU General Public License (GPL)", "Operating System :: OS Independent", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.2", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Topic :: Office/Business :: Groupware"]) Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/000077500000000000000000000000001264614074700212175ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/__init__.py000066400000000000000000000041571264614074700233370ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Tests for Radicale. """ import os import sys from io import BytesIO sys.path.insert(0, os.path.dirname(os.path.dirname(__file__))) os.environ["RADICALE_CONFIG"] = os.path.join(os.path.dirname( os.path.dirname(__file__)), "config") from .helpers import get_file_content class BaseTest(object): """Base class for tests.""" def request(self, method, path, data=None, **args): """Send a request.""" self.application._status = None self.application._headers = None self.application._answer = None for key in args: args[key.upper()] = args[key] args["REQUEST_METHOD"] = method.upper() args["PATH_INFO"] = path if data: if sys.version_info[0] >= 3: data = data.encode("utf-8") args["wsgi.input"] = BytesIO(data) args["CONTENT_LENGTH"] = str(len(data)) self.application._answer = self.application(args, self.start_response) return ( int(self.application._status.split()[0]), dict(self.application._headers), self.application._answer[0].decode("utf-8") if self.application._answer else None) def start_response(self, status, headers): """Put the response values into the current application.""" self.application._status = status self.application._headers = headers Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/custom/000077500000000000000000000000001264614074700225315ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/custom/__init__.py000066400000000000000000000000161264614074700246370ustar00rootroot00000000000000# coding=utf-8Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/custom/auth.py000066400000000000000000000016741264614074700240540ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Custom authentication. Just check username for testing """ def is_authenticated(user, password): return user == 'tmp' Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/custom/storage.py000066400000000000000000000017131264614074700245510ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Custom storage backend. Copy of filesystem storage backend for testing """ from radicale.storage import filesystem class Collection(filesystem.Collection): """Collection stored in a flat ical file.""" Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/helpers.py000066400000000000000000000022601264614074700232330ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2008 Nicolas Kandel # Copyright © 2008 Pascal Halter # Copyright © 2008-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale Helpers module. This module offers helpers to use in tests. """ import os EXAMPLES_FOLDER = os.path.join(os.path.dirname(__file__), "static") def get_file_content(file_name): try: with open(os.path.join(EXAMPLES_FOLDER, file_name)) as fd: return fd.read() except IOError: print("Couldn't open the file %s" % file_name) Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/static/000077500000000000000000000000001264614074700225065ustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/static/event.ics000066400000000000000000000012271264614074700243310ustar00rootroot00000000000000BEGIN:VCALENDAR PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN VERSION:2.0 BEGIN:VTIMEZONE TZID:Europe/Paris X-LIC-LOCATION:Europe/Paris BEGIN:DAYLIGHT TZOFFSETFROM:+0100 TZOFFSETTO:+0200 TZNAME:CEST DTSTART:19700329T020000 RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=3 END:DAYLIGHT BEGIN:STANDARD TZOFFSETFROM:+0200 TZOFFSETTO:+0100 TZNAME:CET DTSTART:19701025T030000 RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10 END:STANDARD END:VTIMEZONE BEGIN:VEVENT CREATED:20130902T150157Z LAST-MODIFIED:20130902T150158Z DTSTAMP:20130902T150158Z UID:event SUMMARY:Event DTSTART;TZID=Europe/Paris:20130902T180000 DTEND;TZID=Europe/Paris:20130902T190000 END:VEVENT END:VCALENDAR Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/static/schema.sql000077700000000000000000000000001264614074700270712../../schema.sqlustar00rootroot00000000000000Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/static/todo.ics000066400000000000000000000003371264614074700241560ustar00rootroot00000000000000BEGIN:VCALENDAR PRODID:-//Mozilla.org/NONSGML Mozilla Calendar V1.1//EN VERSION:2.0 BEGIN:VTODO CREATED:20130903T091105Z LAST-MODIFIED:20130903T091108Z DTSTAMP:20130903T091108Z UID:todo SUMMARY:Todo END:VTODO END:VCALENDAR Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/test_auth.py000066400000000000000000000046551264614074700236030ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012-2013 Guillaume Ayoub # Copyright © 2012-2013 Jean-Marc Martins # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale tests with simple requests and authentication. """ import base64 import hashlib import os import radicale import tempfile from radicale import config from radicale.auth import htpasswd from tests import BaseTest class TestBaseAuthRequests(BaseTest): """Tests basic requests with auth. We should setup auth for each type before creating the Application object. """ def setup(self): self.userpass = "dG1wOmJlcG8=" def teardown(self): config.set("auth", "type", "None") radicale.auth.is_authenticated = lambda *_: True def test_root(self): """Htpasswd authentication.""" self.colpath = tempfile.mkdtemp() htpasswd_file_path = os.path.join(self.colpath, ".htpasswd") with open(htpasswd_file_path, "wb") as fd: fd.write(b"tmp:{SHA}" + base64.b64encode( hashlib.sha1(b"bepo").digest())) config.set("auth", "type", "htpasswd") htpasswd.FILENAME = htpasswd_file_path htpasswd.ENCRYPTION = "sha1" self.application = radicale.Application() status, headers, answer = self.request( "GET", "/", HTTP_AUTHORIZATION=self.userpass) assert status == 200 assert "Radicale works!" in answer def test_custom(self): """Custom authentication.""" config.set("auth", "type", "custom") config.set("auth", "custom_handler", "tests.custom.auth") self.application = radicale.Application() status, headers, answer = self.request( "GET", "/", HTTP_AUTHORIZATION=self.userpass) assert status == 200 assert "Radicale works!" in answer Radicale-3a4184d1aba092629613e6de4b0f438ef1b63360/tests/test_base.py000066400000000000000000000130231264614074700235410ustar00rootroot00000000000000# -*- coding: utf-8 -*- # # This file is part of Radicale Server - Calendar Server # Copyright © 2012-2013 Guillaume Ayoub # # This library is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with Radicale. If not, see . """ Radicale tests with simple requests. """ import radicale import shutil import tempfile from dulwich.repo import Repo from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from . import BaseTest from .helpers import get_file_content class BaseRequests(object): """Tests with simple requests.""" storage_type = None def setup(self): radicale.config.set("storage", "type", self.storage_type) def test_root(self): """GET request at "/".""" status, headers, answer = self.request("GET", "/") assert status == 200 assert "Radicale works!" in answer # Test the creation of the collection status, headers, answer = self.request("GET", "/calendar.ics/") assert "BEGIN:VCALENDAR" in answer #assert "VERSION:2.0" in answer assert "END:VCALENDAR" in answer #assert "PRODID:-//Radicale//NONSGML Radicale Server//EN" in answer def test_add_event(self): """Add an event.""" self.request("GET", "/calendar.ics/") event = get_file_content("event.ics") path = "/calendar.ics/event.ics" status, headers, answer = self.request("PUT", path, event) assert status == 201 status, headers, answer = self.request("GET", path) assert "ETag" in headers.keys() assert status == 200 assert "VEVENT" in answer assert "Event" in answer assert "UID:event" in answer def test_add_todo(self): """Add a todo.""" self.request("GET", "/calendar.ics/") todo = get_file_content("todo.ics") path = "/calendar.ics/todo.ics" status, headers, answer = self.request("PUT", path, todo) assert status == 201 status, headers, answer = self.request("GET", path) assert "ETag" in headers.keys() assert "VTODO" in answer assert "Todo" in answer assert "UID:todo" in answer def test_delete(self): """Delete an event.""" self.request("GET", "/calendar.ics/") event = get_file_content("event.ics") path = "/calendar.ics/event.ics" status, headers, answer = self.request("PUT", path, event) # Then we send a DELETE request status, headers, answer = self.request("DELETE", path) assert status == 200 assert "href>%s