TDE
/
libcaldav
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Initial import

Browse Source
pull/1/head
Timothy Pearson 12 years ago
commit 4462592a15
108 changed files with 31485 additions and 0 deletions
Show Stats Download Patch File Download Diff File

3
AUTHORS
Unescape View File

@ -0,0 +1,3 @@
Michael Rasmussen (mir@datanom.net)
Emmanuel Blindauer (e.blindauer@gmail.com)

674
COPYING
Unescape View File

@ -0,0 +1,674 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
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.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
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 <http://www.gnu.org/licenses/>.
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:
<program> Copyright (C) <year> <name of author>
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
<http://www.gnu.org/licenses/>.
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
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

130
ChangeLog
Unescape View File

@ -0,0 +1,130 @@
libcaldav (0.6.2)
* Fix bug to be able to handle HTTP HEADER lines split
over multiple lines. Patch provided by Timothy Pearson
-- Michael Rasmussen <mir@datanom.net> Tue, 25 May 2010 22:51:03 +0100
libcaldav (0.6.1)
* Fix redirection bug to fully support Zimbra server. Patch
provided by Timothy Pearson
-- Michael Rasmussen <mir@datanom.net> Tue, 25 May 2010 22:51:03 +0100
libcaldav (0.6.0)
* Refactored to properly handle URL schema. Also fixes bug 2985320
* More accurate error message in case of unresolable host or unable
to get a connection. fixes feature request 2985321
* Added support for FREEBUSY search
* Fix bug 3003201. Solution provided by Dmitry Savenko
-- Michael Rasmussen <mir@datanom.net> Mon, 12 Apr 2010 12:15:03 +0100
libcaldav (0.5.2)
* Added a unit like testing framework
* Make the use of locking configurable
* Extend testing framework to test for this
-- Michael Rasmussen <mir@datanom.net> Thu, 8 Apr 2010 12:15:03 +0100
libcaldav (0.5.1)
* Honor request 2981083. Implement a response_free function
* Honor request 2981100. Implement a runtime_info creation function
* Fix bug 2981096. A number of memory leaks
* Complete refactoring. Implement basic setup of curl instance in a
function which all other function uses to ease maintainability and
simplicity and to reduce the number of repeated code lines.
-- Michael Rasmussen <mir@datanom.net> Sat, 3 Apr 2010 03:29:03 +0100
libcaldav (0.5.0)
* Make library thread-safe. Close bug 2971102.
* Changed test application accordingly.
* Fix a number of memory leaks.
* Fix a number of double frees.
* fix regression introduced in revision 9 which broke locking
in delete and modify.
* Enhanced the error reporting for lock requests.
* Fix some potential memory leaks.
* Fix bug in parsing URL for username and password.
* Fix pedantic behaviour from Google which chokes on URL's
containing //
* Fix bug so that get_etag also is able to handle namespace
prefix for finding etags
-- Michael Rasmussen <mir@datanom.net> Sat, 27 Mar 2010 03:27:03 +0100
libcaldav (0.4.2)
* Fix bug so that SSL specific settings are actually used.
Close bug 2971096.
* Fix bug so is-caldav and options are handled correct
* Applied help for new SSL settings to test application
-- Michael Rasmussen <mir@datanom.net> Sat, 27 Mar 2010 03:27:03 +0100
libcaldav (0.4.1)
* Fix bug so that SSL specific errors are handled properly.
Close bug 2963143.
* Add option to build script to disable/enable building of
API documentation. Default is disabled.
* More cleaning up of the build system.
* Fix compile time warnings caused by gcc4.4 and minor change in
libcurl API.
* Add option to disable verification of peer's certificate
* Add option to specify custom CA cert file
-- Michael Rasmussen <mir@datanom.net> Sat, 7 Mar 2010 09:06:24 +0100
libcaldav (0.4.0)
* Extend test client to be able to use both http and https
* Clean up some build instructions
-- Michael Rasmussen <mir@datanom.net> Sat, 27 Feb 2010 12:06:24 +0100
libcaldav (0.3.1)
* Add https support
* make the useragent a configurable string, as some server doesn't like
'curl'
-- Emmanuel Blindauer <e.blindauer@gmail.com> Fri Feb 26 20:49:16 CET 2010
libcaldav (0.3.0)
* This version implements locking if the server supports this. Locking
will be done every time a request for modify or delete is sent to the
server
* 1) In ICalendar all plain text is wrapped inside DTD CDATA elements
* 2) ICalendar does not support collations for text-match in which case
collations has been removed from request - default is i;ascii-casemap anyhow
-- Michael Rasmussen <mir@datanom.net> Thu, 08 Apr 2008 00:06:24 +0100
libcaldav (0.2.0)
* This version is a maintenance release due to important bugs.
* 1) Bugs found in XML which produced incorrect requests corrected
* 2) Added an option to configure to request dynamic or static library
* 3) Build system clean up
* 4) Discovered possible null pointers in error messages which is now
eliminated
* 5) Resolve bug in get_response_header which caused function to
change contents of variable in calling function
* 6) Added extra variable to get_response_header to decide whether returned
string should be all lower or not
7) Function get_tag can now also handle namespace prefix in tags
8) Added function caldav_getoptions to have a list of supported options
by the server returned.
* 9) Compatibily tests run against Chandler and Apple's ICalendar
- Chandler: calendar-query not working due to bugs in Chandler's
implementation of calendar-query which is not conforming to RFC4791
- ICalendar: After adding namespace prefix awareness all test ran as
expected.
* 10) The CLI test application upgraded to use new features.
-- Michael Rasmussen <mir@datanom.net> Thu, 03 Apr 2008 10:10:00 +0100
libcaldav (0.1.0)
* first public release
-- Michael Rasmussen <mir@datanom.net> Tue, 25 Mar 2008 13:20:21 +0100

39
Makefile.am
Unescape View File

@ -0,0 +1,39 @@
AUTOMAKE_OPTIONS = gnu
ACLOCAL_AMFLAGS = -I m4
SUBDIRS = src test
if BUILD_DOC
include aminclude.am
MOSTLYCLEANFILES = \
$(DX_CLEANFILES) \
doc
doxydir = @DX_DOCDIR@
dist_man3_MANS = $(doxydir)/man/man3/caldav.h.3
$(dist_man3_MANS): doxygen-doc
libcaldav_apidoc_filedir = $(docdir)
libcaldav_apidoc_file_DATA = \
doc/libcaldav.pdf
endif
libcaldav_configdir = $(libdir)/pkgconfig
libcaldav_config_DATA = libcaldav.pc
EXTRA_DIST = \
README \
COPYING \
AUTHORS \
ChangeLog \
INSTALL \
NEWS \
TODO \
rfc4791.pdf \
version.sh \
$(dx_config) \
doxygen-api.cfg \
libcaldav.pc \
autogen.sh

1015
Makefile.in
View File

File diff suppressed because it is too large Load Diff

4
NEWS
Unescape View File

@ -0,0 +1,4 @@
2008-03-29 (Michael Rasmussen)
As this is the first public version of the library there is not
so much news appart from the fact, that the library is now publicly
available for download.

19
README
Unescape View File

@ -0,0 +1,19 @@
libcaldav Version 0.1.0
These are the feature so far
- Support for VEVENT
- Add. Add a new event to the collection
- Get. Get one or more events from the collection
- Getall. Get all events from the collection
- Modify. Modify an event
- Delete. Delete an event
- GetCalName. Get the display name from the collection
- IsCalDAV. Test wether a given URL represents a CalDAV collection
See INSTALL for further information.
For an overview of the current status and future feature implementation
study the TODO file.
Happy Hacking
Michael Rasmussen (mir@datanom.net)

10
TODO
Unescape View File

@ -0,0 +1,10 @@
In the nearest future:
- Searching free/busy information is lacking (VFREEBUSY).
- This will be implemented in the next release.
Something to come at a later time:
- Implement ToDo support
- Implement Journal support

186
aminclude.am
Unescape View File

@ -0,0 +1,186 @@
# Copyright (C) 2004 Oren Ben-Kiki
# This file is distributed under the same terms as the Automake macro files.
# Generate automatic documentation using Doxygen. Goals and variables values
# are controlled by the various DX_COND_??? conditionals set by autoconf.
#
# The provided goals are:
# doxygen-doc: Generate all doxygen documentation.
# doxygen-run: Run doxygen, which will generate some of the documentation
# (HTML, CHM, CHI, MAN, RTF, XML) but will not do the post
# processing required for the rest of it (PS, PDF, and some MAN).
# doxygen-man: Rename some doxygen generated man pages.
# doxygen-ps: Generate doxygen PostScript documentation.
# doxygen-pdf: Generate doxygen PDF documentation.
#
# Note that by default these are not integrated into the automake goals. If
# doxygen is used to generate man pages, you can achieve this integration by
# setting man3_MANS to the list of man pages generated and then adding the
# dependency:
#
# $(man3_MANS): doxygen-doc
#
# This will cause make to run doxygen and generate all the documentation.
#
# The following variable is intended for use in Makefile.am:
#
# DX_CLEANFILES = everything to clean.
#
# This is usually added to MOSTLYCLEANFILES.
## --------------------------------- ##
## Format-independent Doxygen rules. ##
## --------------------------------- ##
if DX_COND_doc
## ------------------------------- ##
## Rules specific for HTML output. ##
## ------------------------------- ##
if DX_COND_html
DX_CLEAN_HTML = @DX_DOCDIR@/html
endif DX_COND_html
## ------------------------------ ##
## Rules specific for CHM output. ##
## ------------------------------ ##
if DX_COND_chm
DX_CLEAN_CHM = @DX_DOCDIR@/chm
if DX_COND_chi
DX_CLEAN_CHI = @DX_DOCDIR@/@PACKAGE@.chi
endif DX_COND_chi
endif DX_COND_chm
## ------------------------------ ##
## Rules specific for MAN output. ##
## ------------------------------ ##
if DX_COND_man
DX_CLEAN_MAN = @DX_DOCDIR@/man
endif DX_COND_man
## ------------------------------ ##
## Rules specific for RTF output. ##
## ------------------------------ ##
if DX_COND_rtf
DX_CLEAN_RTF = @DX_DOCDIR@/rtf
endif DX_COND_rtf
## ------------------------------ ##
## Rules specific for XML output. ##
## ------------------------------ ##
if DX_COND_xml
DX_CLEAN_XML = @DX_DOCDIR@/xml
endif DX_COND_xml
## ----------------------------- ##
## Rules specific for PS output. ##
## ----------------------------- ##
if DX_COND_ps
DX_CLEAN_PS = @DX_DOCDIR@/@PACKAGE@.ps
DX_PS_GOAL = doxygen-ps
doxygen-ps: @DX_DOCDIR@/@PACKAGE@.ps
@DX_DOCDIR@/@PACKAGE@.ps: @DX_DOCDIR@/@PACKAGE@.tag
cd @DX_DOCDIR@/latex; \
rm -f *.aux *.toc *.idx *.ind *.ilg *.log *.out; \
$(DX_LATEX) refman.tex; \
$(MAKEINDEX_PATH) refman.idx; \
$(DX_LATEX) refman.tex; \
countdown=5; \
while $(DX_EGREP) 'Rerun (LaTeX|to get cross-references right)' \
refman.log > /dev/null 2>&1 \
&& test $$countdown -gt 0; do \
$(DX_LATEX) refman.tex; \
countdown=`expr $$countdown - 1`; \
done; \
$(DX_DVIPS) -o ../@PACKAGE@.ps refman.dvi
endif DX_COND_ps
## ------------------------------ ##
## Rules specific for PDF output. ##
## ------------------------------ ##
if DX_COND_pdf
DX_CLEAN_PDF = @DX_DOCDIR@/@PACKAGE@.pdf
DX_PDF_GOAL = doxygen-pdf
doxygen-pdf: @DX_DOCDIR@/@PACKAGE@.pdf
@DX_DOCDIR@/@PACKAGE@.pdf: @DX_DOCDIR@/@PACKAGE@.tag
cd @DX_DOCDIR@/latex; \
rm -f *.aux *.toc *.idx *.ind *.ilg *.log *.out; \
$(DX_PDFLATEX) refman.tex; \
$(DX_MAKEINDEX) refman.idx; \
$(DX_PDFLATEX) refman.tex; \
countdown=5; \
while $(DX_EGREP) 'Rerun (LaTeX|to get cross-references right)' \
refman.log > /dev/null 2>&1 \
&& test $$countdown -gt 0; do \
$(DX_PDFLATEX) refman.tex; \
countdown=`expr $$countdown - 1`; \
done; \
mv refman.pdf ../@PACKAGE@.pdf
endif DX_COND_pdf
## ------------------------------------------------- ##
## Rules specific for LaTeX (shared for PS and PDF). ##
## ------------------------------------------------- ##
if DX_COND_latex
DX_CLEAN_LATEX = @DX_DOCDIR@/latex
endif DX_COND_latex
.PHONY: doxygen-run doxygen-doc $(DX_PS_GOAL) $(DX_PDF_GOAL)
.INTERMEDIATE: doxygen-run $(DX_PS_GOAL) $(DX_PDF_GOAL)
doxygen-run: @DX_DOCDIR@/@PACKAGE@.tag
doxygen-doc: doxygen-run $(DX_PS_GOAL) $(DX_PDF_GOAL)
@DX_DOCDIR@/@PACKAGE@.tag: $(DX_CONFIG) $(pkginclude_HEADERS)
rm -rf @DX_DOCDIR@
$(DX_ENV) $(DX_DOXYGEN) $(srcdir)/$(DX_CONFIG)
DX_CLEANFILES = \
@DX_DOCDIR@/@PACKAGE@.tag \
-r \
$(DX_CLEAN_HTML) \
$(DX_CLEAN_CHM) \
$(DX_CLEAN_CHI) \
$(DX_CLEAN_MAN) \
$(DX_CLEAN_RTF) \
$(DX_CLEAN_XML) \
$(DX_CLEAN_PS) \
$(DX_CLEAN_PDF) \
$(DX_CLEAN_LATEX)
endif DX_COND_doc

32
autogen.sh
Unescape View File

@ -0,0 +1,32 @@
#!/bin/sh
echo "Rebuilding build system......"
autoreconf --version 2>&1 > /dev/null 2>&1
if [ $? -eq 0 ]; then
AUTORECONF=autoreconf
else
AUTORECONF=
fi
error() {
echo "Missing tool: $1"
echo "Cannot proceed until the missing tool is available"
exit 1
}
if [ ! -z ${AUTORECONF} ]; then
echo "Using autoreconf to rebuild build system"
autoreconf --force --install --symlink
else
echo "No autoreconf found. Using plain old tools to rebuild build system"
libtoolize --automake --force || error libtoolize
aclocal -I m4|| error aclocal
autoheader --force || error autoheader
automake --add-missing --force-missing --gnu || error automake
autoconf --force || error autoconf
fi
./configure $*
exit 0

146
configure.ac
Unescape View File

@ -0,0 +1,146 @@
# -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.
AC_PREREQ(2.61)
AC_INIT([libcaldav], m4_esyscmd([sh ./version.sh | tr -d '\n']), [mir@datanom.net])
AC_CONFIG_MACRO_DIR([m4])
LIBVERSION=m4_esyscmd([sh ./version.sh LIBTOOL | tr -d '\n'])
AC_SUBST(LIBVERSION)
AC_CANONICAL_SYSTEM
# Generate documentation
# API
DX_HTML_FEATURE(OFF)
DX_CHM_FEATURE(OFF)
DX_CHI_FEATURE(OFF)
DX_MAN_FEATURE(ON)
DX_RTF_FEATURE(OFF)
DX_XML_FEATURE(OFF)
DX_PDF_FEATURE(ON)
DX_PS_FEATURE(OFF)
DX_INIT_DOXYGEN(libcaldav, doxygen-api.cfg, doc)
AM_INIT_AUTOMAKE([dist-bzip2 1.9.6])
AM_MAINTAINER_MODE
AC_CONFIG_HEADER([config.h])
AM_MAINTAINER_MODE
if test $USE_MAINTAINER_MODE = yes; then
CFLAGS="-g -Wall -D_REENTRANT"
STATIC=1
DYNAMIC=0
BUILD_TEST=true
else
#CFLAGS="-g -Wall"
CFLAGS="$CFLAGS -O2 -Wall -D_REENTRANT"
STATIC=0
DYNAMIC=1
BUILD_TEST=false
fi
AM_CONDITIONAL([STATIC_LINK], [test $STATIC -eq 1])
AM_CONDITIONAL([DYNAMIC_LINK], [test $DYNAMIC -eq 1])
# Checks for programs.
AC_PROG_CC
AC_LANG_C
AC_ISC_POSIX
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
AC_HEADER_STDC
AC_PROG_CPP
AM_PROG_LIBTOOL
AC_PROG_INSTALL
# Checks for libraries.
PKG_CHECK_MODULES(CURL, [libcurl >= 7.15.5])
AC_SUBST(CURL_CFLAGS)
AC_SUBST(CURL_LIBS)
PKG_CHECK_MODULES(GLIB, [glib-2.0 >= 2.6 gthread-2.0])
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
#PKG_CHECK_MODULES(OPENSSL, [openssl >= 0.9.8])
#AC_SUBST(OPENSSL_CFLAGS)
#AC_SUBST(OPENSSL_LIBS)
# Checks for header files.
AC_HEADER_STDC
# Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST
AC_TYPE_SIZE_T
AC_STRUCT_TM
# Checks for library functions.
# Should we build test program
AC_ARG_ENABLE([caldav],
[AC_HELP_STRING(--enable-caldav, Build test application (default=no))],
[case "${enableval}" in
yes) caldav=true ;;
no) caldav=false ;;
*) AC_MSG_ERROR([bad value "${enableval}" for --enable-caldav]) ;;
esac], [caldav=$BUILD_TEST])
AM_CONDITIONAL([BUILD_CALDAV], [test x$caldav = xtrue])
# Should we build unit test program
AC_ARG_ENABLE([unittest],
[AC_HELP_STRING(--enable-unittest, Build unti test application (default=no))],
[case "${enableval}" in
yes) unittest=true ;;
no) unittest=false ;;
*) AC_MSG_ERROR([bad value "${enableval}" for --enable-unittest]) ;;
esac], [unittest=$BUILD_TEST])
AM_CONDITIONAL([BUILD_UNITTEST], [test x$unittest = xtrue])
# Build API documentation
AC_ARG_ENABLE([doc],
[AC_HELP_STRING(--enable-doc, Build API documentation (default=no))],
[case "${enableval}" in
yes) doc=true ;;
no) doc=false ;;
*) AC_MSG_ERROR([bad value "${enableval}" for --enable-doc]) ;;
esac], [doc=false])
AM_CONDITIONAL([BUILD_DOC], [test x$doc = xtrue])
AC_CONFIG_COMMANDS(
summary,
[echo ""
echo "libcaldav will be compiled with these settings:"
echo ""
echo -e "\tCFLAGS:\t\t\t\t$cflags"
echo -e "\tBuild caldav-test:\t\t$caldav"
echo -e "\tBuild unittest:\t\t\t$unittest"
echo -e "\tBuild API documentation:\t$doc"
echo -e "\tLibrary is linked:\t\t$link"
echo ""
echo -e "Now run make to build the library"
echo ""
echo -e "Please send bugs or feature requests to the maintainer(s)."
echo -e "Email addresses can be found in the AUTHORS file."
echo ""],
[caldav=${caldav}
unittest=${unittest}
doc=${doc}
cflags="${CFLAGS}"
if test $DYNAMIC -eq 1; then
link="Dynamic"
else
link="Static"
fi]
)
AC_OUTPUT([
Makefile
libcaldav.pc
src/Makefile
test/Makefile
test/src/Makefile
test/ics/Makefile
test/unittest/Makefile
])

250
doxygen-api.cfg
Unescape View File

@ -0,0 +1,250 @@
# Doxyfile 1.5.5
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = $(PROJECT)-$(VERSION)
PROJECT_NUMBER =
OUTPUT_DIRECTORY = $(DOCDIR)
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF = "The $name class" \
"The $name widget" \
"The $name file" \
is \
provides \
specifies \
contains \
represents \
a \
an \
the
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = NO
STRIP_FROM_PATH = $(SRCDIR)/src
STRIP_FROM_INC_PATH = $(SRCDIR)/src
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
QT_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
DETAILS_AT_TOP = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
ALIASES =
OPTIMIZE_OUTPUT_FOR_C = YES
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
BUILTIN_STL_SUPPORT = NO
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
TYPEDEF_HIDES_STRUCT = NO
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = NO
EXTRACT_PRIVATE = NO
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
SHOW_DIRECTORIES = NO
FILE_VERSION_FILTER =
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = YES
WARNINGS = NO
WARN_IF_UNDOCUMENTED = NO
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = $(SRCDIR)/src
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.c \
*.h
RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXCLUDE_SYMBOLS =
EXAMPLE_PATH = $(SRCDIR)/src
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH =
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = NO
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = NO
REFERENCES_LINK_SOURCE = YES
USE_HTAGS = NO
VERBATIM_HEADERS = NO
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
COLS_IN_ALPHA_INDEX = 5
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = $(GENERATE_HTML)
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER =
HTML_FOOTER =
HTML_STYLESHEET =
HTML_ALIGN_MEMBERS = YES
GENERATE_HTMLHELP = NO
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
HTML_DYNAMIC_SECTIONS = NO
CHM_FILE = ../$(PROJECT).chm
HHC_LOCATION = $(HHC_PATH)
GENERATE_CHI = $(GENERATE_CHM)
BINARY_TOC = NO
TOC_EXPAND = NO
DISABLE_INDEX = NO
ENUM_VALUES_PER_LINE = 4
GENERATE_TREEVIEW = YES
TREEVIEW_WIDTH = 250
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = $(GENERATE_LATEX)
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = $(PAPER_SIZE)
EXTRA_PACKAGES =
LATEX_HEADER =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = $(GENERATE_RTF)
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
GENERATE_MAN = $(GENERATE_MAN)
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = NO
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = $(GENERATE_XML)
XML_OUTPUT = xml
XML_SCHEMA =
XML_DTD =
XML_PROGRAMLISTING = YES
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED =
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE = $(DOCDIR)/$(PROJECT).tag
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
PERL_PATH = $(PERL_PATH)
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = NO
MSCGEN_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = $(HAVE_DOT)
CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES
GROUP_GRAPHS = YES
UML_LOOK = NO
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
DOT_PATH = $(DOT_PATH)
DOTFILE_DIRS =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 1000
DOT_TRANSPARENT = YES
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES
#---------------------------------------------------------------------------
# Configuration::additions related to the search engine
#---------------------------------------------------------------------------
SEARCHENGINE = NO

14
libcaldav.pc
Unescape View File

@ -0,0 +1,14 @@
prefix=/usr/local
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include
pkglibdir=${libdir}/libcaldav
pkgincludedir=${includedir}/libcaldav
Name: libcaldav
Description: libcaldav is a client library for CalDAV
Version: 0.6.5
Cflags: -pthread -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include
Libs: -pthread -lgthread-2.0 -lrt -lglib-2.0 -lcurl

14
libcaldav.pc.in
Unescape View File

@ -0,0 +1,14 @@
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
pkglibdir=${libdir}/@PACKAGE@
pkgincludedir=${includedir}/@PACKAGE@
Name: libcaldav
Description: libcaldav is a client library for CalDAV
Version: @VERSION@
Cflags: @GLIB_CFLAGS@ @CURL_CFLAGS@
Libs: @GLIB_LIBS@ @CURL_LIBS@

17
m4/.svn/all-wcprops
Unescape View File

@ -0,0 +1,17 @@
K 25
svn:wc:ra_dav:version-url
V 39
/svnroot/libcaldav/!svn/ver/10/trunk/m4
END
acinclude.m4
K 25
svn:wc:ra_dav:version-url
V 51
/svnroot/libcaldav/!svn/ver/1/trunk/m4/acinclude.m4
END
ax_prog_doxygen.m4
K 25
svn:wc:ra_dav:version-url
V 58
/svnroot/libcaldav/!svn/ver/10/trunk/m4/ax_prog_doxygen.m4
END

96
m4/.svn/entries
Unescape View File

@ -0,0 +1,96 @@
10
dir
42
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav/trunk/m4
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav
2010-02-27T11:17:33.222356Z
10
miras
6bb92309-7149-0410-b568-bc30dfd0a1d5
acinclude.m4
file
2010-05-31T07:07:58.000000Z
9115e99fc4ec059bdd53c777feb4eabf
2008-03-29T18:04:01.076545Z
1
miras
11536
ax_prog_doxygen.m4
file
2010-05-31T07:07:58.000000Z
2d616b8dbbafa6396737ce59661169de
2010-02-27T11:17:33.222356Z
10
miras
has-props
17830

5
m4/.svn/prop-base/ax_prog_doxygen.m4.svn-base
Unescape View File

@ -0,0 +1,5 @@
K 12
svn:keywords
V 22
Author Date Id Rev URL
END

312
m4/.svn/text-base/acinclude.m4.svn-base
Unescape View File

@ -0,0 +1,312 @@
# This file is part of Autoconf. -*- Autoconf -*-
# Copyright (C) 2004 Oren Ben-Kiki
# This file is distributed under the same terms as the Autoconf macro files.
# Generate automatic documentation using Doxygen. Works in concert with the
# aminclude.m4 file and a compatible doxygen configuration file. Defines the
# following public macros:
#
# DX_???_FEATURE(ON|OFF) - control the default setting fo a Doxygen feature.
# Supported features are 'DOXYGEN' itself, 'DOT' for generating graphics,
# 'HTML' for plain HTML, 'CHM' for compressed HTML help (for MS users), 'CHI'
# for generating a seperate .chi file by the .chm file, and 'MAN', 'RTF',
# 'XML', 'PDF' and 'PS' for the appropriate output formats. The environment
# variable DOXYGEN_PAPER_SIZE may be specified to override the default 'a4wide'
# paper size.
#
# By default, HTML, PDF and PS documentation is generated as this seems to be
# the most popular and portable combination. MAN pages created by Doxygen are
# usually problematic, though by picking an appropriate subset and doing some
# massaging they might be better than nothing. CHM and RTF are specific for MS
# (note that you can't generate both HTML and CHM at the same time). The XML is
# rather useless unless you apply specialized post-processing to it.
#
# The macro mainly controls the default state of the feature. The use can
# override the default by specifying --enable or --disable. The macros ensure
# that contradictory flags are not given (e.g., --enable-doxygen-html and
# --enable-doxygen-chm, --enable-doxygen-anything with --disable-doxygen, etc.)
# Finally, each feature will be automatically disabled (with a warning) if the
# required programs are missing.
#
# Once all the feature defaults have been specified, call DX_INIT_DOXYGEN with
# the following parameters: a one-word name for the project for use as a
# filename base etc., an optional configuration file name (the default is
# 'Doxyfile', the same as Doxygen's default), and an optional output directory
# name (the default is 'doxygen-doc').
## ----------##
## Defaults. ##
## ----------##
DX_ENV=""
AC_DEFUN([DX_FEATURE_doc], ON)
AC_DEFUN([DX_FEATURE_dot], ON)
AC_DEFUN([DX_FEATURE_man], OFF)
AC_DEFUN([DX_FEATURE_html], ON)
AC_DEFUN([DX_FEATURE_chm], OFF)
AC_DEFUN([DX_FEATURE_chi], OFF)
AC_DEFUN([DX_FEATURE_rtf], OFF)
AC_DEFUN([DX_FEATURE_xml], OFF)
AC_DEFUN([DX_FEATURE_pdf], ON)
AC_DEFUN([DX_FEATURE_ps], ON)
## --------------- ##
## Private macros. ##
## --------------- ##
# DX_ENV_APPEND(VARIABLE, VALUE)
# ------------------------------
# Append VARIABLE="VALUE" to DX_ENV for invoking doxygen.
AC_DEFUN([DX_ENV_APPEND], [AC_SUBST([DX_ENV], ["$DX_ENV $1='$2'"])])
# DX_DIRNAME_EXPR
# ---------------
# Expand into a shell expression prints the directory part of a path.
AC_DEFUN([DX_DIRNAME_EXPR],
[[expr ".$1" : '\(\.\)[^/]*$' \| "x$1" : 'x\(.*\)/[^/]*$']])
# DX_IF_FEATURE(FEATURE, IF-ON, IF-OFF)
# -------------------------------------
# Expands according to the M4 (static) status of the feature.
AC_DEFUN([DX_IF_FEATURE], [ifelse(DX_FEATURE_$1, ON, [$2], [$3])])
# DX_REQUIRE_PROG(VARIABLE, PROGRAM)
# ----------------------------------
# Require the specified program to be found for the DX_CURRENT_FEATURE to work.
AC_DEFUN([DX_REQUIRE_PROG], [
AC_PATH_TOOL([$1], [$2])
if test "$DX_FLAG_[]DX_CURRENT_FEATURE$$1" = 1; then
AC_MSG_WARN([$2 not found - will not DX_CURRENT_DESCRIPTION])
AC_SUBST([DX_FLAG_[]DX_CURRENT_FEATURE], 0)
fi
])
# DX_TEST_FEATURE(FEATURE)
# ------------------------
# Expand to a shell expression testing whether the feature is active.
AC_DEFUN([DX_TEST_FEATURE], [test "$DX_FLAG_$1" = 1])
# DX_CHECK_DEPEND(REQUIRED_FEATURE, REQUIRED_STATE)
# -------------------------------------------------
# Verify that a required features has the right state before trying to turn on
# the DX_CURRENT_FEATURE.
AC_DEFUN([DX_CHECK_DEPEND], [
test "$DX_FLAG_$1" = "$2" \
|| AC_MSG_ERROR([doxygen-DX_CURRENT_FEATURE ifelse([$2], 1,
requires, contradicts) doxygen-DX_CURRENT_FEATURE])
])
# DX_CLEAR_DEPEND(FEATURE, REQUIRED_FEATURE, REQUIRED_STATE)
# ----------------------------------------------------------
# Turn off the DX_CURRENT_FEATURE if the required feature is off.
AC_DEFUN([DX_CLEAR_DEPEND], [
test "$DX_FLAG_$1" = "$2" || AC_SUBST([DX_FLAG_[]DX_CURRENT_FEATURE], 0)
])
# DX_FEATURE_ARG(FEATURE, DESCRIPTION,
# CHECK_DEPEND, CLEAR_DEPEND,
# REQUIRE, DO-IF-ON, DO-IF-OFF)
# --------------------------------------------
# Parse the command-line option controlling a feature. CHECK_DEPEND is called
# if the user explicitly turns the feature on (and invokes DX_CHECK_DEPEND),
# otherwise CLEAR_DEPEND is called to turn off the default state if a required
# feature is disabled (using DX_CLEAR_DEPEND). REQUIRE performs additional
# requirement tests (DX_REQUIRE_PROG). Finally, an automake flag is set and
# DO-IF-ON or DO-IF-OFF are called according to the final state of the feature.
AC_DEFUN([DX_ARG_ABLE], [
AC_DEFUN([DX_CURRENT_FEATURE], [$1])
AC_DEFUN([DX_CURRENT_DESCRIPTION], [$2])
AC_ARG_ENABLE(doxygen-$1,
[AS_HELP_STRING(DX_IF_FEATURE([$1], [--disable-doxygen-$1],
[--enable-doxygen-$1]),
DX_IF_FEATURE([$1], [don't $2], [$2]))],
[
case "$enableval" in
#(
y|Y|yes|Yes|YES)
AC_SUBST([DX_FLAG_$1], 1)
$3
;; #(
n|N|no|No|NO)
AC_SUBST([DX_FLAG_$1], 0)
;; #(
*)
AC_MSG_ERROR([invalid value '$enableval' given to doxygen-$1])
;;
esac
], [
AC_SUBST([DX_FLAG_$1], [DX_IF_FEATURE([$1], 1, 0)])
$4
])
if DX_TEST_FEATURE([$1]); then
$5
:
fi
if DX_TEST_FEATURE([$1]); then
AM_CONDITIONAL(DX_COND_$1, :)
$6
:
else
AM_CONDITIONAL(DX_COND_$1, false)
$7
:
fi
])
## -------------- ##
## Public macros. ##
## -------------- ##
# DX_XXX_FEATURE(DEFAULT_STATE)
# -----------------------------
AC_DEFUN([DX_DOXYGEN_FEATURE], [AC_DEFUN([DX_FEATURE_doc], [$1])])
AC_DEFUN([DX_MAN_FEATURE], [AC_DEFUN([DX_FEATURE_man], [$1])])
AC_DEFUN([DX_HTML_FEATURE], [AC_DEFUN([DX_FEATURE_html], [$1])])
AC_DEFUN([DX_CHM_FEATURE], [AC_DEFUN([DX_FEATURE_chm], [$1])])
AC_DEFUN([DX_CHI_FEATURE], [AC_DEFUN([DX_FEATURE_chi], [$1])])
AC_DEFUN([DX_RTF_FEATURE], [AC_DEFUN([DX_FEATURE_rtf], [$1])])
AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
AC_DEFUN([DX_PDF_FEATURE], [AC_DEFUN([DX_FEATURE_pdf], [$1])])
AC_DEFUN([DX_PS_FEATURE], [AC_DEFUN([DX_FEATURE_ps], [$1])])
# DX_INIT_DOXYGEN(PROJECT, [CONFIG-FILE], [OUTPUT-DOC-DIR])
# ---------------------------------------------------------
# PROJECT also serves as the base name for the documentation files.
# The default CONFIG-FILE is "Doxyfile" and OUTPUT-DOC-DIR is "doxygen-doc".
AC_DEFUN([DX_INIT_DOXYGEN], [
# Files:
AC_SUBST([DX_PROJECT], [$1])
AC_SUBST([DX_CONFIG], [ifelse([$2], [], Doxyfile, [$2])])
AC_SUBST([DX_DOCDIR], [ifelse([$3], [], doxygen-doc, [$3])])
# Environment variables used inside doxygen.cfg:
DX_ENV_APPEND(SRCDIR, $srcdir)
DX_ENV_APPEND(PROJECT, $DX_PROJECT)
DX_ENV_APPEND(DOCDIR, $DX_DOCDIR)
DX_ENV_APPEND(VERSION, $PACKAGE_VERSION)
# Doxygen itself:
DX_ARG_ABLE(doc, [generate any doxygen documentation],
[],
[],
[DX_REQUIRE_PROG([DX_DOXYGEN], doxygen)
DX_REQUIRE_PROG([DX_PERL], perl)],
[DX_ENV_APPEND(PERL_PATH, $DX_PERL)])
# Dot for graphics:
DX_ARG_ABLE(dot, [generate graphics for doxygen documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_DOT], dot)],
[DX_ENV_APPEND(HAVE_DOT, YES)
DX_ENV_APPEND(DOT_PATH, [`DX_DIRNAME_EXPR($DX_DOT)`])],
[DX_ENV_APPEND(HAVE_DOT, NO)])
# Man pages generation:
DX_ARG_ABLE(man, [generate doxygen manual pages],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_MAN, YES)],
[DX_ENV_APPEND(GENERATE_MAN, NO)])
# RTF file generation:
DX_ARG_ABLE(rtf, [generate doxygen RTF documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_RTF, YES)],
[DX_ENV_APPEND(GENERATE_RTF, NO)])
# XML file generation:
DX_ARG_ABLE(xml, [generate doxygen XML documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_XML, YES)],
[DX_ENV_APPEND(GENERATE_XML, NO)])
# (Compressed) HTML help generation:
DX_ARG_ABLE(chm, [generate doxygen compressed HTML help documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_HHC], hhc)],
[DX_ENV_APPEND(HHC_PATH, $DX_HHC)
DX_ENV_APPEND(GENERATE_HTML, YES)
DX_ENV_APPEND(GENERATE_HTMLHELP, YES)],
[DX_ENV_APPEND(GENERATE_HTMLHELP, NO)])
# Seperate CHI file generation.
DX_ARG_ABLE(chi, [generate doxygen seperate compressed HTML help index file],
[DX_CHECK_DEPEND(chm, 1)],
[DX_CLEAR_DEPEND(chm, 1)],
[],
[DX_ENV_APPEND(GENERATE_CHI, YES)],
[DX_ENV_APPEND(GENERATE_CHI, NO)])
# Plain HTML pages generation:
DX_ARG_ABLE(html, [generate doxygen plain HTML documentation],
[DX_CHECK_DEPEND(doc, 1) DX_CHECK_DEPEND(chm, 0)],
[DX_CLEAR_DEPEND(doc, 1) DX_CLEAR_DEPEND(chm, 0)],
[],
[DX_ENV_APPEND(GENERATE_HTML, YES)],
[DX_TEST_FEATURE(chm) || DX_ENV_APPEND(GENERATE_HTML, NO)])
# PostScript file generation:
DX_ARG_ABLE(ps, [generate doxygen PostScript documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_LATEX], latex)
DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
DX_REQUIRE_PROG([DX_DVIPS], dvips)
DX_REQUIRE_PROG([DX_EGREP], egrep)])
# PDF file generation:
DX_ARG_ABLE(pdf, [generate doxygen PDF documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_PDFLATEX], pdflatex)
DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
DX_REQUIRE_PROG([DX_EGREP], egrep)])
# LaTeX generation for PS and/or PDF:
if DX_TEST_FEATURE(ps) || DX_TEST_FEATURE(pdf); then
AM_CONDITIONAL(DX_COND_latex, :)
DX_ENV_APPEND(GENERATE_LATEX, YES)
else
AM_CONDITIONAL(DX_COND_latex, false)
DX_ENV_APPEND(GENERATE_LATEX, NO)
fi
# Paper size for PS and/or PDF:
AC_ARG_VAR(DOXYGEN_PAPER_SIZE,
[a4wide (default), a4, letter, legal or executive])
case "$DOXYGEN_PAPER_SIZE" in
#(
"")
AC_SUBST(DOXYGEN_PAPER_SIZE, "")
;; #(
a4wide|a4|letter|legal|executive)
DX_ENV_APPEND(PAPER_SIZE, $DOXYGEN_PAPER_SIZE)
;; #(
*)
AC_MSG_ERROR([unknown DOXYGEN_PAPER_SIZE='$DOXYGEN_PAPER_SIZE'])
;;
esac
#For debugging:
#echo DX_FLAG_doc=$DX_FLAG_doc
#echo DX_FLAG_dot=$DX_FLAG_dot
#echo DX_FLAG_man=$DX_FLAG_man
#echo DX_FLAG_html=$DX_FLAG_html
#echo DX_FLAG_chm=$DX_FLAG_chm
#echo DX_FLAG_chi=$DX_FLAG_chi
#echo DX_FLAG_rtf=$DX_FLAG_rtf
#echo DX_FLAG_xml=$DX_FLAG_xml
#echo DX_FLAG_pdf=$DX_FLAG_pdf
#echo DX_FLAG_ps=$DX_FLAG_ps
#echo DX_ENV=$DX_ENV
])

533
m4/.svn/text-base/ax_prog_doxygen.m4.svn-base
Unescape View File

@ -0,0 +1,533 @@
# ===========================================================================
# http://www.nongnu.org/autoconf-archive/ax_prog_doxygen.html
# ===========================================================================
#
# SYNOPSIS
#
# DX_INIT_DOXYGEN(PROJECT-NAME, DOXYFILE-PATH, [OUTPUT-DIR])
# DX_DOXYGEN_FEATURE(ON|OFF)
# DX_DOT_FEATURE(ON|OFF)
# DX_HTML_FEATURE(ON|OFF)
# DX_CHM_FEATURE(ON|OFF)
# DX_CHI_FEATURE(ON|OFF)
# DX_MAN_FEATURE(ON|OFF)
# DX_RTF_FEATURE(ON|OFF)
# DX_XML_FEATURE(ON|OFF)
# DX_PDF_FEATURE(ON|OFF)
# DX_PS_FEATURE(ON|OFF)
#
# DESCRIPTION
#
# The DX_*_FEATURE macros control the default setting for the given
# Doxygen feature. Supported features are 'DOXYGEN' itself, 'DOT' for
# generating graphics, 'HTML' for plain HTML, 'CHM' for compressed HTML
# help (for MS users), 'CHI' for generating a seperate .chi file by the
# .chm file, and 'MAN', 'RTF', 'XML', 'PDF' and 'PS' for the appropriate
# output formats. The environment variable DOXYGEN_PAPER_SIZE may be
# specified to override the default 'a4wide' paper size.
#
# By default, HTML, PDF and PS documentation is generated as this seems to
# be the most popular and portable combination. MAN pages created by
# Doxygen are usually problematic, though by picking an appropriate subset
# and doing some massaging they might be better than nothing. CHM and RTF
# are specific for MS (note that you can't generate both HTML and CHM at
# the same time). The XML is rather useless unless you apply specialized
# post-processing to it.
#
# The macros mainly control the default state of the feature. The use can
# override the default by specifying --enable or --disable. The macros
# ensure that contradictory flags are not given (e.g.,
# --enable-doxygen-html and --enable-doxygen-chm,
# --enable-doxygen-anything with --disable-doxygen, etc.) Finally, each
# feature will be automatically disabled (with a warning) if the required
# programs are missing.
#
# Once all the feature defaults have been specified, call DX_INIT_DOXYGEN
# with the following parameters: a one-word name for the project for use
# as a filename base etc., an optional configuration file name (the
# default is 'Doxyfile', the same as Doxygen's default), and an optional
# output directory name (the default is 'doxygen-doc').
#
# Automake Support
#
# The following is a template aminclude.am file for use with Automake.
# Make targets and variables values are controlled by the various
# DX_COND_* conditionals set by autoconf.
#
# The provided targets are:
#
# doxygen-doc: Generate all doxygen documentation.
#
# doxygen-run: Run doxygen, which will generate some of the
# documentation (HTML, CHM, CHI, MAN, RTF, XML)
# but will not do the post processing required
# for the rest of it (PS, PDF, and some MAN).
#
# doxygen-man: Rename some doxygen generated man pages.
#
# doxygen-ps: Generate doxygen PostScript documentation.
#
# doxygen-pdf: Generate doxygen PDF documentation.
#
# Note that by default these are not integrated into the automake targets.
# If doxygen is used to generate man pages, you can achieve this
# integration by setting man3_MANS to the list of man pages generated and
# then adding the dependency:
#
# $(man3_MANS): doxygen-doc
#
# This will cause make to run doxygen and generate all the documentation.
#
# The following variable is intended for use in Makefile.am:
#
# DX_CLEANFILES = everything to clean.
#
# Then add this variable to MOSTLYCLEANFILES.
#
# ----- begin aminclude.am -------------------------------------
#
# ## --------------------------------- ##
# ## Format-independent Doxygen rules. ##
# ## --------------------------------- ##
#
# if DX_COND_doc
#
# ## ------------------------------- ##
# ## Rules specific for HTML output. ##
# ## ------------------------------- ##
#
# if DX_COND_html
#
# DX_CLEAN_HTML = @DX_DOCDIR@/html
#
# endif DX_COND_html
#
# ## ------------------------------ ##
# ## Rules specific for CHM output. ##
# ## ------------------------------ ##
#
# if DX_COND_chm
#
# DX_CLEAN_CHM = @DX_DOCDIR@/chm
#
# if DX_COND_chi
#
# DX_CLEAN_CHI = @DX_DOCDIR@/@PACKAGE@.chi
#
# endif DX_COND_chi
#
# endif DX_COND_chm
#
# ## ------------------------------ ##
# ## Rules specific for MAN output. ##
# ## ------------------------------ ##
#
# if DX_COND_man
#
# DX_CLEAN_MAN = @DX_DOCDIR@/man
#
# endif DX_COND_man
#
# ## ------------------------------ ##
# ## Rules specific for RTF output. ##
# ## ------------------------------ ##
#
# if DX_COND_rtf
#
# DX_CLEAN_RTF = @DX_DOCDIR@/rtf
#
# endif DX_COND_rtf
#
# ## ------------------------------ ##
# ## Rules specific for XML output. ##
# ## ------------------------------ ##
#
# if DX_COND_xml
#
# DX_CLEAN_XML = @DX_DOCDIR@/xml
#
# endif DX_COND_xml
#
# ## ----------------------------- ##
# ## Rules specific for PS output. ##
# ## ----------------------------- ##
#
# if DX_COND_ps
#
# DX_CLEAN_PS = @DX_DOCDIR@/@PACKAGE@.ps
#
# DX_PS_GOAL = doxygen-ps
#
# doxygen-ps: @DX_DOCDIR@/@PACKAGE@.ps
#
# @DX_DOCDIR@/@PACKAGE@.ps: @DX_DOCDIR@/@PACKAGE@.tag
# cd @DX_DOCDIR@/latex; \
# rm -f *.aux *.toc *.idx *.ind *.ilg *.log *.out; \
# $(DX_LATEX) refman.tex; \
# $(MAKEINDEX_PATH) refman.idx; \
# $(DX_LATEX) refman.tex; \
# countdown=5; \
# while $(DX_EGREP) 'Rerun (LaTeX|to get cross-references right)' \
# refman.log > /dev/null 2>&1 \
# && test $$countdown -gt 0; do \
# $(DX_LATEX) refman.tex; \
# countdown=`expr $$countdown - 1`; \
# done; \
# $(DX_DVIPS) -o ../@PACKAGE@.ps refman.dvi
#
# endif DX_COND_ps
#
# ## ------------------------------ ##
# ## Rules specific for PDF output. ##
# ## ------------------------------ ##
#
# if DX_COND_pdf
#
# DX_CLEAN_PDF = @DX_DOCDIR@/@PACKAGE@.pdf
#
# DX_PDF_GOAL = doxygen-pdf
#
# doxygen-pdf: @DX_DOCDIR@/@PACKAGE@.pdf
#
# @DX_DOCDIR@/@PACKAGE@.pdf: @DX_DOCDIR@/@PACKAGE@.tag
# cd @DX_DOCDIR@/latex; \
# rm -f *.aux *.toc *.idx *.ind *.ilg *.log *.out; \
# $(DX_PDFLATEX) refman.tex; \
# $(DX_MAKEINDEX) refman.idx; \
# $(DX_PDFLATEX) refman.tex; \
# countdown=5; \
# while $(DX_EGREP) 'Rerun (LaTeX|to get cross-references right)' \
# refman.log > /dev/null 2>&1 \
# && test $$countdown -gt 0; do \
# $(DX_PDFLATEX) refman.tex; \
# countdown=`expr $$countdown - 1`; \
# done; \
# mv refman.pdf ../@PACKAGE@.pdf
#
# endif DX_COND_pdf
#
# ## ------------------------------------------------- ##
# ## Rules specific for LaTeX (shared for PS and PDF). ##
# ## ------------------------------------------------- ##
#
# if DX_COND_latex
#
# DX_CLEAN_LATEX = @DX_DOCDIR@/latex
#
# endif DX_COND_latex
#
# .PHONY: doxygen-run doxygen-doc $(DX_PS_GOAL) $(DX_PDF_GOAL)
#
# .INTERMEDIATE: doxygen-run $(DX_PS_GOAL) $(DX_PDF_GOAL)
#
# doxygen-run: @DX_DOCDIR@/@PACKAGE@.tag
#
# doxygen-doc: doxygen-run $(DX_PS_GOAL) $(DX_PDF_GOAL)
#
# @DX_DOCDIR@/@PACKAGE@.tag: $(DX_CONFIG) $(pkginclude_HEADERS)
# rm -rf @DX_DOCDIR@
# $(DX_ENV) $(DX_DOXYGEN) $(srcdir)/$(DX_CONFIG)
#
# DX_CLEANFILES = \
# @DX_DOCDIR@/@PACKAGE@.tag \
# -r \
# $(DX_CLEAN_HTML) \
# $(DX_CLEAN_CHM) \
# $(DX_CLEAN_CHI) \
# $(DX_CLEAN_MAN) \
# $(DX_CLEAN_RTF) \
# $(DX_CLEAN_XML) \
# $(DX_CLEAN_PS) \
# $(DX_CLEAN_PDF) \
# $(DX_CLEAN_LATEX)
#
# endif DX_COND_doc
#
# ----- end aminclude.am ---------------------------------------
#
# LICENSE
#
# Copyright (c) 2009 Oren Ben-Kiki <oren@ben-kiki.org>
#
# Copying and distribution of this file, with or without modification, are
# permitted in any medium without royalty provided the copyright notice
# and this notice are preserved. This file is offered as-is, without any
# warranty.
#serial 9
## ----------##
## Defaults. ##
## ----------##
DX_ENV=""
AC_DEFUN([DX_FEATURE_doc], ON)
AC_DEFUN([DX_FEATURE_dot], ON)
AC_DEFUN([DX_FEATURE_man], OFF)
AC_DEFUN([DX_FEATURE_html], ON)
AC_DEFUN([DX_FEATURE_chm], OFF)
AC_DEFUN([DX_FEATURE_chi], OFF)
AC_DEFUN([DX_FEATURE_rtf], OFF)
AC_DEFUN([DX_FEATURE_xml], OFF)
AC_DEFUN([DX_FEATURE_pdf], ON)
AC_DEFUN([DX_FEATURE_ps], ON)
## --------------- ##
## Private macros. ##
## --------------- ##
# DX_ENV_APPEND(VARIABLE, VALUE)
# ------------------------------
# Append VARIABLE="VALUE" to DX_ENV for invoking doxygen.
AC_DEFUN([DX_ENV_APPEND], [AC_SUBST([DX_ENV], ["$DX_ENV $1='$2'"])])
# DX_DIRNAME_EXPR
# ---------------
# Expand into a shell expression prints the directory part of a path.
AC_DEFUN([DX_DIRNAME_EXPR],
[[expr ".$1" : '\(\.\)[^/]*$' \| "x$1" : 'x\(.*\)/[^/]*$']])
# DX_IF_FEATURE(FEATURE, IF-ON, IF-OFF)
# -------------------------------------
# Expands according to the M4 (static) status of the feature.
AC_DEFUN([DX_IF_FEATURE], [ifelse(DX_FEATURE_$1, ON, [$2], [$3])])
# DX_REQUIRE_PROG(VARIABLE, PROGRAM)
# ----------------------------------
# Require the specified program to be found for the DX_CURRENT_FEATURE to work.
AC_DEFUN([DX_REQUIRE_PROG], [
AC_PATH_TOOL([$1], [$2])
if test "$DX_FLAG_[]DX_CURRENT_FEATURE$$1" = 1; then
AC_MSG_WARN([$2 not found - will not DX_CURRENT_DESCRIPTION])
AC_SUBST(DX_FLAG_[]DX_CURRENT_FEATURE, 0)
fi
])
# DX_TEST_FEATURE(FEATURE)
# ------------------------
# Expand to a shell expression testing whether the feature is active.
AC_DEFUN([DX_TEST_FEATURE], [test "$DX_FLAG_$1" = 1])
# DX_CHECK_DEPEND(REQUIRED_FEATURE, REQUIRED_STATE)
# -------------------------------------------------
# Verify that a required features has the right state before trying to turn on
# the DX_CURRENT_FEATURE.
AC_DEFUN([DX_CHECK_DEPEND], [
test "$DX_FLAG_$1" = "$2" \
|| AC_MSG_ERROR([doxygen-DX_CURRENT_FEATURE ifelse([$2], 1,
requires, contradicts) doxygen-DX_CURRENT_FEATURE])
])
# DX_CLEAR_DEPEND(FEATURE, REQUIRED_FEATURE, REQUIRED_STATE)
# ----------------------------------------------------------
# Turn off the DX_CURRENT_FEATURE if the required feature is off.
AC_DEFUN([DX_CLEAR_DEPEND], [
test "$DX_FLAG_$1" = "$2" || AC_SUBST(DX_FLAG_[]DX_CURRENT_FEATURE, 0)
])
# DX_FEATURE_ARG(FEATURE, DESCRIPTION,
# CHECK_DEPEND, CLEAR_DEPEND,
# REQUIRE, DO-IF-ON, DO-IF-OFF)
# --------------------------------------------
# Parse the command-line option controlling a feature. CHECK_DEPEND is called
# if the user explicitly turns the feature on (and invokes DX_CHECK_DEPEND),
# otherwise CLEAR_DEPEND is called to turn off the default state if a required
# feature is disabled (using DX_CLEAR_DEPEND). REQUIRE performs additional
# requirement tests (DX_REQUIRE_PROG). Finally, an automake flag is set and
# DO-IF-ON or DO-IF-OFF are called according to the final state of the feature.
AC_DEFUN([DX_ARG_ABLE], [
AC_DEFUN([DX_CURRENT_FEATURE], [$1])
AC_DEFUN([DX_CURRENT_DESCRIPTION], [$2])
AC_ARG_ENABLE(doxygen-$1,
[AS_HELP_STRING(DX_IF_FEATURE([$1], [--disable-doxygen-$1],
[--enable-doxygen-$1]),
DX_IF_FEATURE([$1], [don't $2], [$2]))],
[
case "$enableval" in
#(
y|Y|yes|Yes|YES)
AC_SUBST([DX_FLAG_$1], 1)
$3
;; #(
n|N|no|No|NO)
AC_SUBST([DX_FLAG_$1], 0)
;; #(
*)
AC_MSG_ERROR([invalid value '$enableval' given to doxygen-$1])
;;
esac
], [
AC_SUBST([DX_FLAG_$1], [DX_IF_FEATURE([$1], 1, 0)])
$4
])
if DX_TEST_FEATURE([$1]); then
$5
:
fi
if DX_TEST_FEATURE([$1]); then
AM_CONDITIONAL(DX_COND_$1, :)
$6
:
else
AM_CONDITIONAL(DX_COND_$1, false)
$7
:
fi
])
## -------------- ##
## Public macros. ##
## -------------- ##
# DX_XXX_FEATURE(DEFAULT_STATE)
# -----------------------------
AC_DEFUN([DX_DOXYGEN_FEATURE], [AC_DEFUN([DX_FEATURE_doc], [$1])])
AC_DEFUN([DX_MAN_FEATURE], [AC_DEFUN([DX_FEATURE_man], [$1])])
AC_DEFUN([DX_HTML_FEATURE], [AC_DEFUN([DX_FEATURE_html], [$1])])
AC_DEFUN([DX_CHM_FEATURE], [AC_DEFUN([DX_FEATURE_chm], [$1])])
AC_DEFUN([DX_CHI_FEATURE], [AC_DEFUN([DX_FEATURE_chi], [$1])])
AC_DEFUN([DX_RTF_FEATURE], [AC_DEFUN([DX_FEATURE_rtf], [$1])])
AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
AC_DEFUN([DX_PDF_FEATURE], [AC_DEFUN([DX_FEATURE_pdf], [$1])])
AC_DEFUN([DX_PS_FEATURE], [AC_DEFUN([DX_FEATURE_ps], [$1])])
# DX_INIT_DOXYGEN(PROJECT, [CONFIG-FILE], [OUTPUT-DOC-DIR])
# ---------------------------------------------------------
# PROJECT also serves as the base name for the documentation files.
# The default CONFIG-FILE is "Doxyfile" and OUTPUT-DOC-DIR is "doxygen-doc".
AC_DEFUN([DX_INIT_DOXYGEN], [
# Files:
AC_SUBST([DX_PROJECT], [$1])
AC_SUBST([DX_CONFIG], [ifelse([$2], [], Doxyfile, [$2])])
AC_SUBST([DX_DOCDIR], [ifelse([$3], [], doxygen-doc, [$3])])
# Environment variables used inside doxygen.cfg:
DX_ENV_APPEND(SRCDIR, $srcdir)
DX_ENV_APPEND(PROJECT, $DX_PROJECT)
DX_ENV_APPEND(DOCDIR, $DX_DOCDIR)
DX_ENV_APPEND(VERSION, $PACKAGE_VERSION)
# Doxygen itself:
DX_ARG_ABLE(doc, [generate any doxygen documentation],
[],
[],
[DX_REQUIRE_PROG([DX_DOXYGEN], doxygen)
DX_REQUIRE_PROG([DX_PERL], perl)],
[DX_ENV_APPEND(PERL_PATH, $DX_PERL)])
# Dot for graphics:
DX_ARG_ABLE(dot, [generate graphics for doxygen documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_DOT], dot)],
[DX_ENV_APPEND(HAVE_DOT, YES)
DX_ENV_APPEND(DOT_PATH, [`DX_DIRNAME_EXPR($DX_DOT)`])],
[DX_ENV_APPEND(HAVE_DOT, NO)])
# Man pages generation:
DX_ARG_ABLE(man, [generate doxygen manual pages],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_MAN, YES)],
[DX_ENV_APPEND(GENERATE_MAN, NO)])
# RTF file generation:
DX_ARG_ABLE(rtf, [generate doxygen RTF documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_RTF, YES)],
[DX_ENV_APPEND(GENERATE_RTF, NO)])
# XML file generation:
DX_ARG_ABLE(xml, [generate doxygen XML documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_XML, YES)],
[DX_ENV_APPEND(GENERATE_XML, NO)])
# (Compressed) HTML help generation:
DX_ARG_ABLE(chm, [generate doxygen compressed HTML help documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_HHC], hhc)],
[DX_ENV_APPEND(HHC_PATH, $DX_HHC)
DX_ENV_APPEND(GENERATE_HTML, YES)
DX_ENV_APPEND(GENERATE_HTMLHELP, YES)],
[DX_ENV_APPEND(GENERATE_HTMLHELP, NO)])
# Seperate CHI file generation.
DX_ARG_ABLE(chi, [generate doxygen seperate compressed HTML help index file],
[DX_CHECK_DEPEND(chm, 1)],
[DX_CLEAR_DEPEND(chm, 1)],
[],
[DX_ENV_APPEND(GENERATE_CHI, YES)],
[DX_ENV_APPEND(GENERATE_CHI, NO)])
# Plain HTML pages generation:
DX_ARG_ABLE(html, [generate doxygen plain HTML documentation],
[DX_CHECK_DEPEND(doc, 1) DX_CHECK_DEPEND(chm, 0)],
[DX_CLEAR_DEPEND(doc, 1) DX_CLEAR_DEPEND(chm, 0)],
[],
[DX_ENV_APPEND(GENERATE_HTML, YES)],
[DX_TEST_FEATURE(chm) || DX_ENV_APPEND(GENERATE_HTML, NO)])
# PostScript file generation:
DX_ARG_ABLE(ps, [generate doxygen PostScript documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_LATEX], latex)
DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
DX_REQUIRE_PROG([DX_DVIPS], dvips)
DX_REQUIRE_PROG([DX_EGREP], egrep)])
# PDF file generation:
DX_ARG_ABLE(pdf, [generate doxygen PDF documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_PDFLATEX], pdflatex)
DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
DX_REQUIRE_PROG([DX_EGREP], egrep)])
# LaTeX generation for PS and/or PDF:
if DX_TEST_FEATURE(ps) || DX_TEST_FEATURE(pdf); then
AM_CONDITIONAL(DX_COND_latex, :)
DX_ENV_APPEND(GENERATE_LATEX, YES)
else
AM_CONDITIONAL(DX_COND_latex, false)
DX_ENV_APPEND(GENERATE_LATEX, NO)
fi
# Paper size for PS and/or PDF:
AC_ARG_VAR(DOXYGEN_PAPER_SIZE,
[a4wide (default), a4, letter, legal or executive])
case "$DOXYGEN_PAPER_SIZE" in
#(
"")
AC_SUBST(DOXYGEN_PAPER_SIZE, "")
;; #(
a4wide|a4|letter|legal|executive)
DX_ENV_APPEND(PAPER_SIZE, $DOXYGEN_PAPER_SIZE)
;; #(
*)
AC_MSG_ERROR([unknown DOXYGEN_PAPER_SIZE='$DOXYGEN_PAPER_SIZE'])
;;
esac
#For debugging:
#echo DX_FLAG_doc=$DX_FLAG_doc
#echo DX_FLAG_dot=$DX_FLAG_dot
#echo DX_FLAG_man=$DX_FLAG_man
#echo DX_FLAG_html=$DX_FLAG_html
#echo DX_FLAG_chm=$DX_FLAG_chm
#echo DX_FLAG_chi=$DX_FLAG_chi
#echo DX_FLAG_rtf=$DX_FLAG_rtf
#echo DX_FLAG_xml=$DX_FLAG_xml
#echo DX_FLAG_pdf=$DX_FLAG_pdf
#echo DX_FLAG_ps=$DX_FLAG_ps
#echo DX_ENV=$DX_ENV
])

312
m4/acinclude.m4
Unescape View File

@ -0,0 +1,312 @@
# This file is part of Autoconf. -*- Autoconf -*-
# Copyright (C) 2004 Oren Ben-Kiki
# This file is distributed under the same terms as the Autoconf macro files.
# Generate automatic documentation using Doxygen. Works in concert with the
# aminclude.m4 file and a compatible doxygen configuration file. Defines the
# following public macros:
#
# DX_???_FEATURE(ON|OFF) - control the default setting fo a Doxygen feature.
# Supported features are 'DOXYGEN' itself, 'DOT' for generating graphics,
# 'HTML' for plain HTML, 'CHM' for compressed HTML help (for MS users), 'CHI'
# for generating a seperate .chi file by the .chm file, and 'MAN', 'RTF',
# 'XML', 'PDF' and 'PS' for the appropriate output formats. The environment
# variable DOXYGEN_PAPER_SIZE may be specified to override the default 'a4wide'
# paper size.
#
# By default, HTML, PDF and PS documentation is generated as this seems to be
# the most popular and portable combination. MAN pages created by Doxygen are
# usually problematic, though by picking an appropriate subset and doing some
# massaging they might be better than nothing. CHM and RTF are specific for MS
# (note that you can't generate both HTML and CHM at the same time). The XML is
# rather useless unless you apply specialized post-processing to it.
#
# The macro mainly controls the default state of the feature. The use can
# override the default by specifying --enable or --disable. The macros ensure
# that contradictory flags are not given (e.g., --enable-doxygen-html and
# --enable-doxygen-chm, --enable-doxygen-anything with --disable-doxygen, etc.)
# Finally, each feature will be automatically disabled (with a warning) if the
# required programs are missing.
#
# Once all the feature defaults have been specified, call DX_INIT_DOXYGEN with
# the following parameters: a one-word name for the project for use as a
# filename base etc., an optional configuration file name (the default is
# 'Doxyfile', the same as Doxygen's default), and an optional output directory
# name (the default is 'doxygen-doc').
## ----------##
## Defaults. ##
## ----------##
DX_ENV=""
AC_DEFUN([DX_FEATURE_doc], ON)
AC_DEFUN([DX_FEATURE_dot], ON)
AC_DEFUN([DX_FEATURE_man], OFF)
AC_DEFUN([DX_FEATURE_html], ON)
AC_DEFUN([DX_FEATURE_chm], OFF)
AC_DEFUN([DX_FEATURE_chi], OFF)
AC_DEFUN([DX_FEATURE_rtf], OFF)
AC_DEFUN([DX_FEATURE_xml], OFF)
AC_DEFUN([DX_FEATURE_pdf], ON)
AC_DEFUN([DX_FEATURE_ps], ON)
## --------------- ##
## Private macros. ##
## --------------- ##
# DX_ENV_APPEND(VARIABLE, VALUE)
# ------------------------------
# Append VARIABLE="VALUE" to DX_ENV for invoking doxygen.
AC_DEFUN([DX_ENV_APPEND], [AC_SUBST([DX_ENV], ["$DX_ENV $1='$2'"])])
# DX_DIRNAME_EXPR
# ---------------
# Expand into a shell expression prints the directory part of a path.
AC_DEFUN([DX_DIRNAME_EXPR],
[[expr ".$1" : '\(\.\)[^/]*$' \| "x$1" : 'x\(.*\)/[^/]*$']])
# DX_IF_FEATURE(FEATURE, IF-ON, IF-OFF)
# -------------------------------------
# Expands according to the M4 (static) status of the feature.
AC_DEFUN([DX_IF_FEATURE], [ifelse(DX_FEATURE_$1, ON, [$2], [$3])])
# DX_REQUIRE_PROG(VARIABLE, PROGRAM)
# ----------------------------------
# Require the specified program to be found for the DX_CURRENT_FEATURE to work.
AC_DEFUN([DX_REQUIRE_PROG], [
AC_PATH_TOOL([$1], [$2])
if test "$DX_FLAG_[]DX_CURRENT_FEATURE$$1" = 1; then
AC_MSG_WARN([$2 not found - will not DX_CURRENT_DESCRIPTION])
AC_SUBST([DX_FLAG_[]DX_CURRENT_FEATURE], 0)
fi
])
# DX_TEST_FEATURE(FEATURE)
# ------------------------
# Expand to a shell expression testing whether the feature is active.
AC_DEFUN([DX_TEST_FEATURE], [test "$DX_FLAG_$1" = 1])
# DX_CHECK_DEPEND(REQUIRED_FEATURE, REQUIRED_STATE)
# -------------------------------------------------
# Verify that a required features has the right state before trying to turn on
# the DX_CURRENT_FEATURE.
AC_DEFUN([DX_CHECK_DEPEND], [
test "$DX_FLAG_$1" = "$2" \
|| AC_MSG_ERROR([doxygen-DX_CURRENT_FEATURE ifelse([$2], 1,
requires, contradicts) doxygen-DX_CURRENT_FEATURE])
])
# DX_CLEAR_DEPEND(FEATURE, REQUIRED_FEATURE, REQUIRED_STATE)
# ----------------------------------------------------------
# Turn off the DX_CURRENT_FEATURE if the required feature is off.
AC_DEFUN([DX_CLEAR_DEPEND], [
test "$DX_FLAG_$1" = "$2" || AC_SUBST([DX_FLAG_[]DX_CURRENT_FEATURE], 0)
])
# DX_FEATURE_ARG(FEATURE, DESCRIPTION,
# CHECK_DEPEND, CLEAR_DEPEND,
# REQUIRE, DO-IF-ON, DO-IF-OFF)
# --------------------------------------------
# Parse the command-line option controlling a feature. CHECK_DEPEND is called
# if the user explicitly turns the feature on (and invokes DX_CHECK_DEPEND),
# otherwise CLEAR_DEPEND is called to turn off the default state if a required
# feature is disabled (using DX_CLEAR_DEPEND). REQUIRE performs additional
# requirement tests (DX_REQUIRE_PROG). Finally, an automake flag is set and
# DO-IF-ON or DO-IF-OFF are called according to the final state of the feature.
AC_DEFUN([DX_ARG_ABLE], [
AC_DEFUN([DX_CURRENT_FEATURE], [$1])
AC_DEFUN([DX_CURRENT_DESCRIPTION], [$2])
AC_ARG_ENABLE(doxygen-$1,
[AS_HELP_STRING(DX_IF_FEATURE([$1], [--disable-doxygen-$1],
[--enable-doxygen-$1]),
DX_IF_FEATURE([$1], [don't $2], [$2]))],
[
case "$enableval" in
#(
y|Y|yes|Yes|YES)
AC_SUBST([DX_FLAG_$1], 1)
$3
;; #(
n|N|no|No|NO)
AC_SUBST([DX_FLAG_$1], 0)
;; #(
*)
AC_MSG_ERROR([invalid value '$enableval' given to doxygen-$1])
;;
esac
], [
AC_SUBST([DX_FLAG_$1], [DX_IF_FEATURE([$1], 1, 0)])
$4
])
if DX_TEST_FEATURE([$1]); then
$5
:
fi
if DX_TEST_FEATURE([$1]); then
AM_CONDITIONAL(DX_COND_$1, :)
$6
:
else
AM_CONDITIONAL(DX_COND_$1, false)
$7
:
fi
])
## -------------- ##
## Public macros. ##
## -------------- ##
# DX_XXX_FEATURE(DEFAULT_STATE)
# -----------------------------
AC_DEFUN([DX_DOXYGEN_FEATURE], [AC_DEFUN([DX_FEATURE_doc], [$1])])
AC_DEFUN([DX_MAN_FEATURE], [AC_DEFUN([DX_FEATURE_man], [$1])])
AC_DEFUN([DX_HTML_FEATURE], [AC_DEFUN([DX_FEATURE_html], [$1])])
AC_DEFUN([DX_CHM_FEATURE], [AC_DEFUN([DX_FEATURE_chm], [$1])])
AC_DEFUN([DX_CHI_FEATURE], [AC_DEFUN([DX_FEATURE_chi], [$1])])
AC_DEFUN([DX_RTF_FEATURE], [AC_DEFUN([DX_FEATURE_rtf], [$1])])
AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
AC_DEFUN([DX_PDF_FEATURE], [AC_DEFUN([DX_FEATURE_pdf], [$1])])
AC_DEFUN([DX_PS_FEATURE], [AC_DEFUN([DX_FEATURE_ps], [$1])])
# DX_INIT_DOXYGEN(PROJECT, [CONFIG-FILE], [OUTPUT-DOC-DIR])
# ---------------------------------------------------------
# PROJECT also serves as the base name for the documentation files.
# The default CONFIG-FILE is "Doxyfile" and OUTPUT-DOC-DIR is "doxygen-doc".
AC_DEFUN([DX_INIT_DOXYGEN], [
# Files:
AC_SUBST([DX_PROJECT], [$1])
AC_SUBST([DX_CONFIG], [ifelse([$2], [], Doxyfile, [$2])])
AC_SUBST([DX_DOCDIR], [ifelse([$3], [], doxygen-doc, [$3])])
# Environment variables used inside doxygen.cfg:
DX_ENV_APPEND(SRCDIR, $srcdir)
DX_ENV_APPEND(PROJECT, $DX_PROJECT)
DX_ENV_APPEND(DOCDIR, $DX_DOCDIR)
DX_ENV_APPEND(VERSION, $PACKAGE_VERSION)
# Doxygen itself:
DX_ARG_ABLE(doc, [generate any doxygen documentation],
[],
[],
[DX_REQUIRE_PROG([DX_DOXYGEN], doxygen)
DX_REQUIRE_PROG([DX_PERL], perl)],
[DX_ENV_APPEND(PERL_PATH, $DX_PERL)])
# Dot for graphics:
DX_ARG_ABLE(dot, [generate graphics for doxygen documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_DOT], dot)],
[DX_ENV_APPEND(HAVE_DOT, YES)
DX_ENV_APPEND(DOT_PATH, [`DX_DIRNAME_EXPR($DX_DOT)`])],
[DX_ENV_APPEND(HAVE_DOT, NO)])
# Man pages generation:
DX_ARG_ABLE(man, [generate doxygen manual pages],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_MAN, YES)],
[DX_ENV_APPEND(GENERATE_MAN, NO)])
# RTF file generation:
DX_ARG_ABLE(rtf, [generate doxygen RTF documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_RTF, YES)],
[DX_ENV_APPEND(GENERATE_RTF, NO)])
# XML file generation:
DX_ARG_ABLE(xml, [generate doxygen XML documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_XML, YES)],
[DX_ENV_APPEND(GENERATE_XML, NO)])
# (Compressed) HTML help generation:
DX_ARG_ABLE(chm, [generate doxygen compressed HTML help documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_HHC], hhc)],
[DX_ENV_APPEND(HHC_PATH, $DX_HHC)
DX_ENV_APPEND(GENERATE_HTML, YES)
DX_ENV_APPEND(GENERATE_HTMLHELP, YES)],
[DX_ENV_APPEND(GENERATE_HTMLHELP, NO)])
# Seperate CHI file generation.
DX_ARG_ABLE(chi, [generate doxygen seperate compressed HTML help index file],
[DX_CHECK_DEPEND(chm, 1)],
[DX_CLEAR_DEPEND(chm, 1)],
[],
[DX_ENV_APPEND(GENERATE_CHI, YES)],
[DX_ENV_APPEND(GENERATE_CHI, NO)])
# Plain HTML pages generation:
DX_ARG_ABLE(html, [generate doxygen plain HTML documentation],
[DX_CHECK_DEPEND(doc, 1) DX_CHECK_DEPEND(chm, 0)],
[DX_CLEAR_DEPEND(doc, 1) DX_CLEAR_DEPEND(chm, 0)],
[],
[DX_ENV_APPEND(GENERATE_HTML, YES)],
[DX_TEST_FEATURE(chm) || DX_ENV_APPEND(GENERATE_HTML, NO)])
# PostScript file generation:
DX_ARG_ABLE(ps, [generate doxygen PostScript documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_LATEX], latex)
DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
DX_REQUIRE_PROG([DX_DVIPS], dvips)
DX_REQUIRE_PROG([DX_EGREP], egrep)])
# PDF file generation:
DX_ARG_ABLE(pdf, [generate doxygen PDF documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_PDFLATEX], pdflatex)
DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
DX_REQUIRE_PROG([DX_EGREP], egrep)])
# LaTeX generation for PS and/or PDF:
if DX_TEST_FEATURE(ps) || DX_TEST_FEATURE(pdf); then
AM_CONDITIONAL(DX_COND_latex, :)
DX_ENV_APPEND(GENERATE_LATEX, YES)
else
AM_CONDITIONAL(DX_COND_latex, false)
DX_ENV_APPEND(GENERATE_LATEX, NO)
fi
# Paper size for PS and/or PDF:
AC_ARG_VAR(DOXYGEN_PAPER_SIZE,
[a4wide (default), a4, letter, legal or executive])
case "$DOXYGEN_PAPER_SIZE" in
#(
"")
AC_SUBST(DOXYGEN_PAPER_SIZE, "")
;; #(
a4wide|a4|letter|legal|executive)
DX_ENV_APPEND(PAPER_SIZE, $DOXYGEN_PAPER_SIZE)
;; #(
*)
AC_MSG_ERROR([unknown DOXYGEN_PAPER_SIZE='$DOXYGEN_PAPER_SIZE'])
;;
esac
#For debugging:
#echo DX_FLAG_doc=$DX_FLAG_doc
#echo DX_FLAG_dot=$DX_FLAG_dot
#echo DX_FLAG_man=$DX_FLAG_man
#echo DX_FLAG_html=$DX_FLAG_html
#echo DX_FLAG_chm=$DX_FLAG_chm
#echo DX_FLAG_chi=$DX_FLAG_chi
#echo DX_FLAG_rtf=$DX_FLAG_rtf
#echo DX_FLAG_xml=$DX_FLAG_xml
#echo DX_FLAG_pdf=$DX_FLAG_pdf
#echo DX_FLAG_ps=$DX_FLAG_ps
#echo DX_ENV=$DX_ENV
])

533
m4/ax_prog_doxygen.m4
Unescape View File

@ -0,0 +1,533 @@
# ===========================================================================
# http://www.nongnu.org/autoconf-archive/ax_prog_doxygen.html
# ===========================================================================
#
# SYNOPSIS
#
# DX_INIT_DOXYGEN(PROJECT-NAME, DOXYFILE-PATH, [OUTPUT-DIR])
# DX_DOXYGEN_FEATURE(ON|OFF)
# DX_DOT_FEATURE(ON|OFF)
# DX_HTML_FEATURE(ON|OFF)
# DX_CHM_FEATURE(ON|OFF)
# DX_CHI_FEATURE(ON|OFF)
# DX_MAN_FEATURE(ON|OFF)
# DX_RTF_FEATURE(ON|OFF)
# DX_XML_FEATURE(ON|OFF)
# DX_PDF_FEATURE(ON|OFF)
# DX_PS_FEATURE(ON|OFF)
#
# DESCRIPTION
#
# The DX_*_FEATURE macros control the default setting for the given
# Doxygen feature. Supported features are 'DOXYGEN' itself, 'DOT' for
# generating graphics, 'HTML' for plain HTML, 'CHM' for compressed HTML
# help (for MS users), 'CHI' for generating a seperate .chi file by the
# .chm file, and 'MAN', 'RTF', 'XML', 'PDF' and 'PS' for the appropriate
# output formats. The environment variable DOXYGEN_PAPER_SIZE may be
# specified to override the default 'a4wide' paper size.
#
# By default, HTML, PDF and PS documentation is generated as this seems to
# be the most popular and portable combination. MAN pages created by
# Doxygen are usually problematic, though by picking an appropriate subset
# and doing some massaging they might be better than nothing. CHM and RTF
# are specific for MS (note that you can't generate both HTML and CHM at
# the same time). The XML is rather useless unless you apply specialized
# post-processing to it.
#
# The macros mainly control the default state of the feature. The use can
# override the default by specifying --enable or --disable. The macros
# ensure that contradictory flags are not given (e.g.,
# --enable-doxygen-html and --enable-doxygen-chm,
# --enable-doxygen-anything with --disable-doxygen, etc.) Finally, each
# feature will be automatically disabled (with a warning) if the required
# programs are missing.
#
# Once all the feature defaults have been specified, call DX_INIT_DOXYGEN
# with the following parameters: a one-word name for the project for use
# as a filename base etc., an optional configuration file name (the
# default is 'Doxyfile', the same as Doxygen's default), and an optional
# output directory name (the default is 'doxygen-doc').
#
# Automake Support
#
# The following is a template aminclude.am file for use with Automake.
# Make targets and variables values are controlled by the various
# DX_COND_* conditionals set by autoconf.
#
# The provided targets are:
#
# doxygen-doc: Generate all doxygen documentation.
#
# doxygen-run: Run doxygen, which will generate some of the
# documentation (HTML, CHM, CHI, MAN, RTF, XML)
# but will not do the post processing required
# for the rest of it (PS, PDF, and some MAN).
#
# doxygen-man: Rename some doxygen generated man pages.
#
# doxygen-ps: Generate doxygen PostScript documentation.
#
# doxygen-pdf: Generate doxygen PDF documentation.
#
# Note that by default these are not integrated into the automake targets.
# If doxygen is used to generate man pages, you can achieve this
# integration by setting man3_MANS to the list of man pages generated and
# then adding the dependency:
#
# $(man3_MANS): doxygen-doc
#
# This will cause make to run doxygen and generate all the documentation.
#
# The following variable is intended for use in Makefile.am:
#
# DX_CLEANFILES = everything to clean.
#
# Then add this variable to MOSTLYCLEANFILES.
#
# ----- begin aminclude.am -------------------------------------
#
# ## --------------------------------- ##
# ## Format-independent Doxygen rules. ##
# ## --------------------------------- ##
#
# if DX_COND_doc
#
# ## ------------------------------- ##
# ## Rules specific for HTML output. ##
# ## ------------------------------- ##
#
# if DX_COND_html
#
# DX_CLEAN_HTML = @DX_DOCDIR@/html
#
# endif DX_COND_html
#
# ## ------------------------------ ##
# ## Rules specific for CHM output. ##
# ## ------------------------------ ##
#
# if DX_COND_chm
#
# DX_CLEAN_CHM = @DX_DOCDIR@/chm
#
# if DX_COND_chi
#
# DX_CLEAN_CHI = @DX_DOCDIR@/@PACKAGE@.chi
#
# endif DX_COND_chi
#
# endif DX_COND_chm
#
# ## ------------------------------ ##
# ## Rules specific for MAN output. ##
# ## ------------------------------ ##
#
# if DX_COND_man
#
# DX_CLEAN_MAN = @DX_DOCDIR@/man
#
# endif DX_COND_man
#
# ## ------------------------------ ##
# ## Rules specific for RTF output. ##
# ## ------------------------------ ##
#
# if DX_COND_rtf
#
# DX_CLEAN_RTF = @DX_DOCDIR@/rtf
#
# endif DX_COND_rtf
#
# ## ------------------------------ ##
# ## Rules specific for XML output. ##
# ## ------------------------------ ##
#
# if DX_COND_xml
#
# DX_CLEAN_XML = @DX_DOCDIR@/xml
#
# endif DX_COND_xml
#
# ## ----------------------------- ##
# ## Rules specific for PS output. ##
# ## ----------------------------- ##
#
# if DX_COND_ps
#
# DX_CLEAN_PS = @DX_DOCDIR@/@PACKAGE@.ps
#
# DX_PS_GOAL = doxygen-ps
#
# doxygen-ps: @DX_DOCDIR@/@PACKAGE@.ps
#
# @DX_DOCDIR@/@PACKAGE@.ps: @DX_DOCDIR@/@PACKAGE@.tag
# cd @DX_DOCDIR@/latex; \
# rm -f *.aux *.toc *.idx *.ind *.ilg *.log *.out; \
# $(DX_LATEX) refman.tex; \
# $(MAKEINDEX_PATH) refman.idx; \
# $(DX_LATEX) refman.tex; \
# countdown=5; \
# while $(DX_EGREP) 'Rerun (LaTeX|to get cross-references right)' \
# refman.log > /dev/null 2>&1 \
# && test $$countdown -gt 0; do \
# $(DX_LATEX) refman.tex; \
# countdown=`expr $$countdown - 1`; \
# done; \
# $(DX_DVIPS) -o ../@PACKAGE@.ps refman.dvi
#
# endif DX_COND_ps
#
# ## ------------------------------ ##
# ## Rules specific for PDF output. ##
# ## ------------------------------ ##
#
# if DX_COND_pdf
#
# DX_CLEAN_PDF = @DX_DOCDIR@/@PACKAGE@.pdf
#
# DX_PDF_GOAL = doxygen-pdf
#
# doxygen-pdf: @DX_DOCDIR@/@PACKAGE@.pdf
#
# @DX_DOCDIR@/@PACKAGE@.pdf: @DX_DOCDIR@/@PACKAGE@.tag
# cd @DX_DOCDIR@/latex; \
# rm -f *.aux *.toc *.idx *.ind *.ilg *.log *.out; \
# $(DX_PDFLATEX) refman.tex; \
# $(DX_MAKEINDEX) refman.idx; \
# $(DX_PDFLATEX) refman.tex; \
# countdown=5; \
# while $(DX_EGREP) 'Rerun (LaTeX|to get cross-references right)' \
# refman.log > /dev/null 2>&1 \
# && test $$countdown -gt 0; do \
# $(DX_PDFLATEX) refman.tex; \
# countdown=`expr $$countdown - 1`; \
# done; \
# mv refman.pdf ../@PACKAGE@.pdf
#
# endif DX_COND_pdf
#
# ## ------------------------------------------------- ##
# ## Rules specific for LaTeX (shared for PS and PDF). ##
# ## ------------------------------------------------- ##
#
# if DX_COND_latex
#
# DX_CLEAN_LATEX = @DX_DOCDIR@/latex
#
# endif DX_COND_latex
#
# .PHONY: doxygen-run doxygen-doc $(DX_PS_GOAL) $(DX_PDF_GOAL)
#
# .INTERMEDIATE: doxygen-run $(DX_PS_GOAL) $(DX_PDF_GOAL)
#
# doxygen-run: @DX_DOCDIR@/@PACKAGE@.tag
#
# doxygen-doc: doxygen-run $(DX_PS_GOAL) $(DX_PDF_GOAL)
#
# @DX_DOCDIR@/@PACKAGE@.tag: $(DX_CONFIG) $(pkginclude_HEADERS)
# rm -rf @DX_DOCDIR@
# $(DX_ENV) $(DX_DOXYGEN) $(srcdir)/$(DX_CONFIG)
#
# DX_CLEANFILES = \
# @DX_DOCDIR@/@PACKAGE@.tag \
# -r \
# $(DX_CLEAN_HTML) \
# $(DX_CLEAN_CHM) \
# $(DX_CLEAN_CHI) \
# $(DX_CLEAN_MAN) \
# $(DX_CLEAN_RTF) \
# $(DX_CLEAN_XML) \
# $(DX_CLEAN_PS) \
# $(DX_CLEAN_PDF) \
# $(DX_CLEAN_LATEX)
#
# endif DX_COND_doc
#
# ----- end aminclude.am ---------------------------------------
#
# LICENSE
#
# Copyright (c) 2009 Oren Ben-Kiki <oren@ben-kiki.org>
#
# Copying and distribution of this file, with or without modification, are
# permitted in any medium without royalty provided the copyright notice
# and this notice are preserved. This file is offered as-is, without any
# warranty.
#serial 9
## ----------##
## Defaults. ##
## ----------##
DX_ENV=""
AC_DEFUN([DX_FEATURE_doc], ON)
AC_DEFUN([DX_FEATURE_dot], ON)
AC_DEFUN([DX_FEATURE_man], OFF)
AC_DEFUN([DX_FEATURE_html], ON)
AC_DEFUN([DX_FEATURE_chm], OFF)
AC_DEFUN([DX_FEATURE_chi], OFF)
AC_DEFUN([DX_FEATURE_rtf], OFF)
AC_DEFUN([DX_FEATURE_xml], OFF)
AC_DEFUN([DX_FEATURE_pdf], ON)
AC_DEFUN([DX_FEATURE_ps], ON)
## --------------- ##
## Private macros. ##
## --------------- ##
# DX_ENV_APPEND(VARIABLE, VALUE)
# ------------------------------
# Append VARIABLE="VALUE" to DX_ENV for invoking doxygen.
AC_DEFUN([DX_ENV_APPEND], [AC_SUBST([DX_ENV], ["$DX_ENV $1='$2'"])])
# DX_DIRNAME_EXPR
# ---------------
# Expand into a shell expression prints the directory part of a path.
AC_DEFUN([DX_DIRNAME_EXPR],
[[expr ".$1" : '\(\.\)[^/]*$' \| "x$1" : 'x\(.*\)/[^/]*$']])
# DX_IF_FEATURE(FEATURE, IF-ON, IF-OFF)
# -------------------------------------
# Expands according to the M4 (static) status of the feature.
AC_DEFUN([DX_IF_FEATURE], [ifelse(DX_FEATURE_$1, ON, [$2], [$3])])
# DX_REQUIRE_PROG(VARIABLE, PROGRAM)
# ----------------------------------
# Require the specified program to be found for the DX_CURRENT_FEATURE to work.
AC_DEFUN([DX_REQUIRE_PROG], [
AC_PATH_TOOL([$1], [$2])
if test "$DX_FLAG_[]DX_CURRENT_FEATURE$$1" = 1; then
AC_MSG_WARN([$2 not found - will not DX_CURRENT_DESCRIPTION])
AC_SUBST(DX_FLAG_[]DX_CURRENT_FEATURE, 0)
fi
])
# DX_TEST_FEATURE(FEATURE)
# ------------------------
# Expand to a shell expression testing whether the feature is active.
AC_DEFUN([DX_TEST_FEATURE], [test "$DX_FLAG_$1" = 1])
# DX_CHECK_DEPEND(REQUIRED_FEATURE, REQUIRED_STATE)
# -------------------------------------------------
# Verify that a required features has the right state before trying to turn on
# the DX_CURRENT_FEATURE.
AC_DEFUN([DX_CHECK_DEPEND], [
test "$DX_FLAG_$1" = "$2" \
|| AC_MSG_ERROR([doxygen-DX_CURRENT_FEATURE ifelse([$2], 1,
requires, contradicts) doxygen-DX_CURRENT_FEATURE])
])
# DX_CLEAR_DEPEND(FEATURE, REQUIRED_FEATURE, REQUIRED_STATE)
# ----------------------------------------------------------
# Turn off the DX_CURRENT_FEATURE if the required feature is off.
AC_DEFUN([DX_CLEAR_DEPEND], [
test "$DX_FLAG_$1" = "$2" || AC_SUBST(DX_FLAG_[]DX_CURRENT_FEATURE, 0)
])
# DX_FEATURE_ARG(FEATURE, DESCRIPTION,
# CHECK_DEPEND, CLEAR_DEPEND,
# REQUIRE, DO-IF-ON, DO-IF-OFF)
# --------------------------------------------
# Parse the command-line option controlling a feature. CHECK_DEPEND is called
# if the user explicitly turns the feature on (and invokes DX_CHECK_DEPEND),
# otherwise CLEAR_DEPEND is called to turn off the default state if a required
# feature is disabled (using DX_CLEAR_DEPEND). REQUIRE performs additional
# requirement tests (DX_REQUIRE_PROG). Finally, an automake flag is set and
# DO-IF-ON or DO-IF-OFF are called according to the final state of the feature.
AC_DEFUN([DX_ARG_ABLE], [
AC_DEFUN([DX_CURRENT_FEATURE], [$1])
AC_DEFUN([DX_CURRENT_DESCRIPTION], [$2])
AC_ARG_ENABLE(doxygen-$1,
[AS_HELP_STRING(DX_IF_FEATURE([$1], [--disable-doxygen-$1],
[--enable-doxygen-$1]),
DX_IF_FEATURE([$1], [don't $2], [$2]))],
[
case "$enableval" in
#(
y|Y|yes|Yes|YES)
AC_SUBST([DX_FLAG_$1], 1)
$3
;; #(
n|N|no|No|NO)
AC_SUBST([DX_FLAG_$1], 0)
;; #(
*)
AC_MSG_ERROR([invalid value '$enableval' given to doxygen-$1])
;;
esac
], [
AC_SUBST([DX_FLAG_$1], [DX_IF_FEATURE([$1], 1, 0)])
$4
])
if DX_TEST_FEATURE([$1]); then
$5
:
fi
if DX_TEST_FEATURE([$1]); then
AM_CONDITIONAL(DX_COND_$1, :)
$6
:
else
AM_CONDITIONAL(DX_COND_$1, false)
$7
:
fi
])
## -------------- ##
## Public macros. ##
## -------------- ##
# DX_XXX_FEATURE(DEFAULT_STATE)
# -----------------------------
AC_DEFUN([DX_DOXYGEN_FEATURE], [AC_DEFUN([DX_FEATURE_doc], [$1])])
AC_DEFUN([DX_MAN_FEATURE], [AC_DEFUN([DX_FEATURE_man], [$1])])
AC_DEFUN([DX_HTML_FEATURE], [AC_DEFUN([DX_FEATURE_html], [$1])])
AC_DEFUN([DX_CHM_FEATURE], [AC_DEFUN([DX_FEATURE_chm], [$1])])
AC_DEFUN([DX_CHI_FEATURE], [AC_DEFUN([DX_FEATURE_chi], [$1])])
AC_DEFUN([DX_RTF_FEATURE], [AC_DEFUN([DX_FEATURE_rtf], [$1])])
AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
AC_DEFUN([DX_XML_FEATURE], [AC_DEFUN([DX_FEATURE_xml], [$1])])
AC_DEFUN([DX_PDF_FEATURE], [AC_DEFUN([DX_FEATURE_pdf], [$1])])
AC_DEFUN([DX_PS_FEATURE], [AC_DEFUN([DX_FEATURE_ps], [$1])])
# DX_INIT_DOXYGEN(PROJECT, [CONFIG-FILE], [OUTPUT-DOC-DIR])
# ---------------------------------------------------------
# PROJECT also serves as the base name for the documentation files.
# The default CONFIG-FILE is "Doxyfile" and OUTPUT-DOC-DIR is "doxygen-doc".
AC_DEFUN([DX_INIT_DOXYGEN], [
# Files:
AC_SUBST([DX_PROJECT], [$1])
AC_SUBST([DX_CONFIG], [ifelse([$2], [], Doxyfile, [$2])])
AC_SUBST([DX_DOCDIR], [ifelse([$3], [], doxygen-doc, [$3])])
# Environment variables used inside doxygen.cfg:
DX_ENV_APPEND(SRCDIR, $srcdir)
DX_ENV_APPEND(PROJECT, $DX_PROJECT)
DX_ENV_APPEND(DOCDIR, $DX_DOCDIR)
DX_ENV_APPEND(VERSION, $PACKAGE_VERSION)
# Doxygen itself:
DX_ARG_ABLE(doc, [generate any doxygen documentation],
[],
[],
[DX_REQUIRE_PROG([DX_DOXYGEN], doxygen)
DX_REQUIRE_PROG([DX_PERL], perl)],
[DX_ENV_APPEND(PERL_PATH, $DX_PERL)])
# Dot for graphics:
DX_ARG_ABLE(dot, [generate graphics for doxygen documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_DOT], dot)],
[DX_ENV_APPEND(HAVE_DOT, YES)
DX_ENV_APPEND(DOT_PATH, [`DX_DIRNAME_EXPR($DX_DOT)`])],
[DX_ENV_APPEND(HAVE_DOT, NO)])
# Man pages generation:
DX_ARG_ABLE(man, [generate doxygen manual pages],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_MAN, YES)],
[DX_ENV_APPEND(GENERATE_MAN, NO)])
# RTF file generation:
DX_ARG_ABLE(rtf, [generate doxygen RTF documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_RTF, YES)],
[DX_ENV_APPEND(GENERATE_RTF, NO)])
# XML file generation:
DX_ARG_ABLE(xml, [generate doxygen XML documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[],
[DX_ENV_APPEND(GENERATE_XML, YES)],
[DX_ENV_APPEND(GENERATE_XML, NO)])
# (Compressed) HTML help generation:
DX_ARG_ABLE(chm, [generate doxygen compressed HTML help documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_HHC], hhc)],
[DX_ENV_APPEND(HHC_PATH, $DX_HHC)
DX_ENV_APPEND(GENERATE_HTML, YES)
DX_ENV_APPEND(GENERATE_HTMLHELP, YES)],
[DX_ENV_APPEND(GENERATE_HTMLHELP, NO)])
# Seperate CHI file generation.
DX_ARG_ABLE(chi, [generate doxygen seperate compressed HTML help index file],
[DX_CHECK_DEPEND(chm, 1)],
[DX_CLEAR_DEPEND(chm, 1)],
[],
[DX_ENV_APPEND(GENERATE_CHI, YES)],
[DX_ENV_APPEND(GENERATE_CHI, NO)])
# Plain HTML pages generation:
DX_ARG_ABLE(html, [generate doxygen plain HTML documentation],
[DX_CHECK_DEPEND(doc, 1) DX_CHECK_DEPEND(chm, 0)],
[DX_CLEAR_DEPEND(doc, 1) DX_CLEAR_DEPEND(chm, 0)],
[],
[DX_ENV_APPEND(GENERATE_HTML, YES)],
[DX_TEST_FEATURE(chm) || DX_ENV_APPEND(GENERATE_HTML, NO)])
# PostScript file generation:
DX_ARG_ABLE(ps, [generate doxygen PostScript documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_LATEX], latex)
DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
DX_REQUIRE_PROG([DX_DVIPS], dvips)
DX_REQUIRE_PROG([DX_EGREP], egrep)])
# PDF file generation:
DX_ARG_ABLE(pdf, [generate doxygen PDF documentation],
[DX_CHECK_DEPEND(doc, 1)],
[DX_CLEAR_DEPEND(doc, 1)],
[DX_REQUIRE_PROG([DX_PDFLATEX], pdflatex)
DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
DX_REQUIRE_PROG([DX_EGREP], egrep)])
# LaTeX generation for PS and/or PDF:
if DX_TEST_FEATURE(ps) || DX_TEST_FEATURE(pdf); then
AM_CONDITIONAL(DX_COND_latex, :)
DX_ENV_APPEND(GENERATE_LATEX, YES)
else
AM_CONDITIONAL(DX_COND_latex, false)
DX_ENV_APPEND(GENERATE_LATEX, NO)
fi
# Paper size for PS and/or PDF:
AC_ARG_VAR(DOXYGEN_PAPER_SIZE,
[a4wide (default), a4, letter, legal or executive])
case "$DOXYGEN_PAPER_SIZE" in
#(
"")
AC_SUBST(DOXYGEN_PAPER_SIZE, "")
;; #(
a4wide|a4|letter|legal|executive)
DX_ENV_APPEND(PAPER_SIZE, $DOXYGEN_PAPER_SIZE)
;; #(
*)
AC_MSG_ERROR([unknown DOXYGEN_PAPER_SIZE='$DOXYGEN_PAPER_SIZE'])
;;
esac
#For debugging:
#echo DX_FLAG_doc=$DX_FLAG_doc
#echo DX_FLAG_dot=$DX_FLAG_dot
#echo DX_FLAG_man=$DX_FLAG_man
#echo DX_FLAG_html=$DX_FLAG_html
#echo DX_FLAG_chm=$DX_FLAG_chm
#echo DX_FLAG_chi=$DX_FLAG_chi
#echo DX_FLAG_rtf=$DX_FLAG_rtf
#echo DX_FLAG_xml=$DX_FLAG_xml
#echo DX_FLAG_pdf=$DX_FLAG_pdf
#echo DX_FLAG_ps=$DX_FLAG_ps
#echo DX_ENV=$DX_ENV
])

7663
rfc4791.pdf
View File

File diff suppressed because one or more lines are too long

137
src/.svn/all-wcprops
Unescape View File

@ -0,0 +1,137 @@
K 25
svn:wc:ra_dav:version-url
V 40
/svnroot/libcaldav/!svn/ver/42/trunk/src
END
delete-caldav-object.c
K 25
svn:wc:ra_dav:version-url
V 63
/svnroot/libcaldav/!svn/ver/41/trunk/src/delete-caldav-object.c
END
caldav.h
K 25
svn:wc:ra_dav:version-url
V 49
/svnroot/libcaldav/!svn/ver/39/trunk/src/caldav.h
END
get-display-name.c
K 25
svn:wc:ra_dav:version-url
V 59
/svnroot/libcaldav/!svn/ver/41/trunk/src/get-display-name.c
END
Makefile.in
K 25
svn:wc:ra_dav:version-url
V 52
/svnroot/libcaldav/!svn/ver/42/trunk/src/Makefile.in
END
delete-caldav-object.h
K 25
svn:wc:ra_dav:version-url
V 62
/svnroot/libcaldav/!svn/ver/1/trunk/src/delete-caldav-object.h
END
get-display-name.h
K 25
svn:wc:ra_dav:version-url
V 58
/svnroot/libcaldav/!svn/ver/1/trunk/src/get-display-name.h
END
get-caldav-report.c
K 25
svn:wc:ra_dav:version-url
V 60
/svnroot/libcaldav/!svn/ver/41/trunk/src/get-caldav-report.c
END
modify-caldav-object.c
K 25
svn:wc:ra_dav:version-url
V 63
/svnroot/libcaldav/!svn/ver/41/trunk/src/modify-caldav-object.c
END
lock-caldav-object.c
K 25
svn:wc:ra_dav:version-url
V 61
/svnroot/libcaldav/!svn/ver/41/trunk/src/lock-caldav-object.c
END
add-caldav-object.c
K 25
svn:wc:ra_dav:version-url
V 60
/svnroot/libcaldav/!svn/ver/41/trunk/src/add-caldav-object.c
END
get-caldav-report.h
K 25
svn:wc:ra_dav:version-url
V 60
/svnroot/libcaldav/!svn/ver/39/trunk/src/get-caldav-report.h
END
md5.c
K 25
svn:wc:ra_dav:version-url
V 45
/svnroot/libcaldav/!svn/ver/1/trunk/src/md5.c
END
options-caldav-server.c
K 25
svn:wc:ra_dav:version-url
V 64
/svnroot/libcaldav/!svn/ver/41/trunk/src/options-caldav-server.c
END
caldav-utils.c
K 25
svn:wc:ra_dav:version-url
V 55
/svnroot/libcaldav/!svn/ver/42/trunk/src/caldav-utils.c
END
Makefile.am
K 25
svn:wc:ra_dav:version-url
V 52
/svnroot/libcaldav/!svn/ver/39/trunk/src/Makefile.am
END
modify-caldav-object.h
K 25
svn:wc:ra_dav:version-url
V 62
/svnroot/libcaldav/!svn/ver/1/trunk/src/modify-caldav-object.h
END
lock-caldav-object.h
K 25
svn:wc:ra_dav:version-url
V 60
/svnroot/libcaldav/!svn/ver/9/trunk/src/lock-caldav-object.h
END
add-caldav-object.h
K 25
svn:wc:ra_dav:version-url
V 59
/svnroot/libcaldav/!svn/ver/1/trunk/src/add-caldav-object.h
END
caldav.c
K 25
svn:wc:ra_dav:version-url
V 49
/svnroot/libcaldav/!svn/ver/39/trunk/src/caldav.c
END
md5.h
K 25
svn:wc:ra_dav:version-url
V 45
/svnroot/libcaldav/!svn/ver/1/trunk/src/md5.h
END
options-caldav-server.h
K 25
svn:wc:ra_dav:version-url
V 64
/svnroot/libcaldav/!svn/ver/10/trunk/src/options-caldav-server.h
END
caldav-utils.h
K 25
svn:wc:ra_dav:version-url
V 55
/svnroot/libcaldav/!svn/ver/34/trunk/src/caldav-utils.h
END

776
src/.svn/entries
Unescape View File

@ -0,0 +1,776 @@
10
dir
42
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav/trunk/src
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav
2010-05-29T15:45:56.236020Z
42
miras
6bb92309-7149-0410-b568-bc30dfd0a1d5
delete-caldav-object.c
file
2010-05-31T07:07:58.000000Z
fab35eb73b0fb9581aa487decd83b6c6
2010-05-25T20:53:04.081178Z
41
miras
8643
caldav.h
file
2010-05-31T07:07:58.000000Z
8b27bf73c1c7bb060ad21312f5f9af05
2010-05-23T20:43:55.305076Z
39
miras
11331
get-display-name.c
file
2010-05-31T07:07:58.000000Z
e605700922c480f35815279a20484248
2010-05-25T20:53:04.081178Z
41
miras
4631
Makefile.in
file
2010-05-31T07:07:58.000000Z
dd17920f8308f34a5cb6f4c546fb59ea
2010-05-29T15:45:56.236020Z
42
miras
21254
delete-caldav-object.h
file
2010-05-31T07:07:58.000000Z
a73e19682e34e9c903940f3f0fd48435
2008-03-29T18:04:01.076545Z
1
miras
1244
get-display-name.h
file
2010-05-31T07:07:58.000000Z
78c67f8d08738e976c2decb360d90eac
2008-03-29T18:04:01.076545Z
1
miras
1240
get-caldav-report.c
file
2010-05-31T07:07:58.000000Z
fd4ef5b191fc0b3a7ea76b14a078e06c
2010-05-25T20:53:04.081178Z
41
miras
8572
modify-caldav-object.c
file
2010-05-31T07:07:58.000000Z
18119fb7cabfe0a193035aad23ccacef
2010-05-25T20:53:04.081178Z
41
miras
8992
lock-caldav-object.c
file
2010-05-31T07:07:58.000000Z
d94186940ab1caf2a060ae6bc4a836ca
2010-05-25T20:53:04.081178Z
41
miras
9360
add-caldav-object.c
file
2010-05-31T07:07:58.000000Z
9272e45b03647c432efbc8d8a6217537
2010-05-25T20:53:04.081178Z
41
miras
4341
get-caldav-report.h
file
2010-05-31T07:07:58.000000Z
4063fdac318ff1c4b8d5845fd6d526f3
2010-05-23T20:43:55.305076Z
39
miras
1609
md5.c
file
2010-05-31T07:07:58.000000Z
4c393b2163ae5ab0d8461709e4680b68
2008-03-29T18:04:01.076545Z
1
miras
11719
options-caldav-server.c
file
2010-05-31T07:07:58.000000Z
bca50708fda598af1cf6c3171bf01e0d
2010-05-25T20:53:04.081178Z
41
miras
4545
Makefile.am
file
2010-05-31T07:07:58.000000Z
d4e689953457ac1f09d9bc85d4d3e855
2010-05-23T20:43:55.305076Z
39
miras
1098
modify-caldav-object.h
file
2010-05-31T07:07:58.000000Z
7369d16e16cb3d208a3d576f69685f76
2008-03-29T18:04:01.076545Z
1
miras
1244
caldav-utils.c
file
2010-05-31T07:07:58.000000Z
fb4b55bfc19b10aba28e8e047a9493bc
2010-05-29T15:45:56.236020Z
42
miras
17444
lock-caldav-object.h
file
2010-05-31T07:07:58.000000Z
1f07eba06bb4fe89eb8c42a6fb67df55
2008-04-07T22:11:32.666799Z
9
miras
2088
add-caldav-object.h
file
2010-05-31T07:07:58.000000Z
4f4e1336005bc1eb283696d92ce6075f
2008-03-29T18:04:01.076545Z
1
miras
1236
caldav.c
file
2010-05-31T07:07:58.000000Z
6307ba82867c515caa761ea0e03c9e0d
2010-05-23T20:43:55.305076Z
39
miras
21199
md5.h
file
2010-05-31T07:07:58.000000Z
5238bb8df57b98358aa184bb97d686d5
2008-03-29T18:04:01.076545Z
1
miras
1517
options-caldav-server.h
file
2010-05-31T07:07:58.000000Z
100c2c473b064d0b0c99135a3f8c8992
2010-02-27T11:17:33.222356Z
10
miras
1774
caldav-utils.h
file
2010-05-31T07:07:58.000000Z
790120ed34d83d7a82dd21e6543c65fc
2010-04-07T22:56:57.177660Z
34
miras
5300

53
src/.svn/text-base/Makefile.am.svn-base
Unescape View File

@ -0,0 +1,53 @@
AUTOMAKE_OPTIONS = gnu
INCLUDES = @CURL_CFLAGS@ @GLIB_CFLAGS@ \
-I$(top_srcdir) -I$(top_builddir)
if STATIC_LINK
noinst_LTLIBRARIES = libcaldav.la
endif
if DYNAMIC_LINK
lib_LTLIBRARIES = libcaldav.la
endif
libcaldav_la_LDFLAGS = -version-info @LIBVERSION@
libcaldav_la_SOURCES = \
caldav.h \
caldav.c \
add-caldav-object.c \
add-caldav-object.h \
delete-caldav-object.c \
delete-caldav-object.h \
modify-caldav-object.c \
modify-caldav-object.h \
get-caldav-report.c \
get-caldav-report.h \
get-display-name.c \
get-display-name.h \
caldav-utils.c \
caldav-utils.h \
md5.c \
md5.h \
options-caldav-server.c \
options-caldav-server.h \
lock-caldav-object.c \
lock-caldav-object.h \
get-freebusy-report.c \
get-freebusy-report.h
libcaldav_includedir=$(includedir)/libcaldav-@VERSION@
libcaldav_include_HEADERS = caldav.h
noinst_HEADERS = \
add-caldav-object.h \
delete-caldav-object.h \
modify-caldav-object.h \
get-caldav-report.h \
caldav-utils.h
libcaldav_la_LIBADD = \
@CURL_LIBS@ \
@GLIB_LIBS@

649
src/.svn/text-base/Makefile.in.svn-base
Unescape View File

@ -0,0 +1,649 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = src
DIST_COMMON = $(libcaldav_include_HEADERS) $(noinst_HEADERS) \
$(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__installdirs = "$(DESTDIR)$(libdir)" \
"$(DESTDIR)$(libcaldav_includedir)"
LTLIBRARIES = $(lib_LTLIBRARIES) $(noinst_LTLIBRARIES)
libcaldav_la_DEPENDENCIES =
am_libcaldav_la_OBJECTS = caldav.lo add-caldav-object.lo \
delete-caldav-object.lo modify-caldav-object.lo \
get-caldav-report.lo get-display-name.lo caldav-utils.lo \
md5.lo options-caldav-server.lo lock-caldav-object.lo \
get-freebusy-report.lo
libcaldav_la_OBJECTS = $(am_libcaldav_la_OBJECTS)
libcaldav_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(libcaldav_la_LDFLAGS) $(LDFLAGS) -o $@
@DYNAMIC_LINK_TRUE@am_libcaldav_la_rpath = -rpath $(libdir)
@STATIC_LINK_TRUE@am_libcaldav_la_rpath =
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(libcaldav_la_SOURCES)
DIST_SOURCES = $(libcaldav_la_SOURCES)
HEADERS = $(libcaldav_include_HEADERS) $(noinst_HEADERS)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
INCLUDES = @CURL_CFLAGS@ @GLIB_CFLAGS@ \
-I$(top_srcdir) -I$(top_builddir)
@STATIC_LINK_TRUE@noinst_LTLIBRARIES = libcaldav.la
@DYNAMIC_LINK_TRUE@lib_LTLIBRARIES = libcaldav.la
libcaldav_la_LDFLAGS = -version-info @LIBVERSION@
libcaldav_la_SOURCES = \
caldav.h \
caldav.c \
add-caldav-object.c \
add-caldav-object.h \
delete-caldav-object.c \
delete-caldav-object.h \
modify-caldav-object.c \
modify-caldav-object.h \
get-caldav-report.c \
get-caldav-report.h \
get-display-name.c \
get-display-name.h \
caldav-utils.c \
caldav-utils.h \
md5.c \
md5.h \
options-caldav-server.c \
options-caldav-server.h \
lock-caldav-object.c \
lock-caldav-object.h \
get-freebusy-report.c \
get-freebusy-report.h
libcaldav_includedir = $(includedir)/libcaldav-@VERSION@
libcaldav_include_HEADERS = caldav.h
noinst_HEADERS = \
add-caldav-object.h \
delete-caldav-object.h \
modify-caldav-object.h \
get-caldav-report.h \
caldav-utils.h
libcaldav_la_LIBADD = \
@CURL_LIBS@ \
@GLIB_LIBS@
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu src/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
install-libLTLIBRARIES: $(lib_LTLIBRARIES)
@$(NORMAL_INSTALL)
test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"
@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
list2=; for p in $$list; do \
if test -f $$p; then \
list2="$$list2 $$p"; \
else :; fi; \
done; \
test -z "$$list2" || { \
echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
$(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
}
uninstall-libLTLIBRARIES:
@$(NORMAL_UNINSTALL)
@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
for p in $$list; do \
$(am__strip_dir) \
echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
$(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
done
clean-libLTLIBRARIES:
-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
test "$$dir" != "$$p" || dir=.; \
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
clean-noinstLTLIBRARIES:
-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
test "$$dir" != "$$p" || dir=.; \
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
libcaldav.la: $(libcaldav_la_OBJECTS) $(libcaldav_la_DEPENDENCIES)
$(libcaldav_la_LINK) $(am_libcaldav_la_rpath) $(libcaldav_la_OBJECTS) $(libcaldav_la_LIBADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/add-caldav-object.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/caldav-utils.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/caldav.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/delete-caldav-object.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get-caldav-report.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get-display-name.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get-freebusy-report.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lock-caldav-object.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/md5.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/modify-caldav-object.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/options-caldav-server.Plo@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
install-libcaldav_includeHEADERS: $(libcaldav_include_HEADERS)
@$(NORMAL_INSTALL)
test -z "$(libcaldav_includedir)" || $(MKDIR_P) "$(DESTDIR)$(libcaldav_includedir)"
@list='$(libcaldav_include_HEADERS)'; test -n "$(libcaldav_includedir)" || list=; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
echo "$$d$$p"; \
done | $(am__base_list) | \
while read files; do \
echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(libcaldav_includedir)'"; \
$(INSTALL_HEADER) $$files "$(DESTDIR)$(libcaldav_includedir)" || exit $$?; \
done
uninstall-libcaldav_includeHEADERS:
@$(NORMAL_UNINSTALL)
@list='$(libcaldav_include_HEADERS)'; test -n "$(libcaldav_includedir)" || list=; \
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
test -n "$$files" || exit 0; \
echo " ( cd '$(DESTDIR)$(libcaldav_includedir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(libcaldav_includedir)" && rm -f $$files
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(LTLIBRARIES) $(HEADERS)
installdirs:
for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libcaldav_includedir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
clean-noinstLTLIBRARIES mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am: install-libcaldav_includeHEADERS
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-libLTLIBRARIES
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-libLTLIBRARIES \
uninstall-libcaldav_includeHEADERS
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
clean-libLTLIBRARIES clean-libtool clean-noinstLTLIBRARIES \
ctags distclean distclean-compile distclean-generic \
distclean-libtool distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-libLTLIBRARIES \
install-libcaldav_includeHEADERS install-man install-pdf \
install-pdf-am install-ps install-ps-am install-strip \
installcheck installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
tags uninstall uninstall-am uninstall-libLTLIBRARIES \
uninstall-libcaldav_includeHEADERS
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

131
src/.svn/text-base/add-caldav-object.c.svn-base
Unescape View File

@ -0,0 +1,131 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "add-caldav-object.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* Function for adding a new event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_add(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
gchar* url;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "If-None-Match: *");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* tmp = random_file_name(settings->file);
gchar* s = rebuild_url(settings, NULL);
if (g_str_has_suffix(s, "/")) {
url = g_strdup_printf("%slibcaldav-%s.ics", s, tmp);
}
else {
url = g_strdup_printf("%s/libcaldav-%s.ics", s, tmp);
}
g_free(s);
g_free(tmp);
curl_easy_setopt(curl, CURLOPT_URL, url);
tmp = g_strdup(settings->file);
g_free(settings->file);
settings->file = verify_uid(tmp);
g_free(tmp);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, settings->file);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(settings->file));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 201) {
error->str = g_strdup(chunk.memory);
error->code = code;
result = TRUE;
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}

35
src/.svn/text-base/add-caldav-object.h.svn-base
Unescape View File

@ -0,0 +1,35 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __ADD_CALDAV_OBJECT_H__
#define __ADD_CALDAV_OBJECT_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function for adding a new event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_add(caldav_settings* settings, caldav_error* error);
#endif

713
src/.svn/text-base/caldav-utils.c.svn-base
Unescape View File

@ -0,0 +1,713 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "caldav-utils.h"
#include "md5.h"
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <curl/curl.h>
#include <ctype.h>
/**
* This function is burrowed from the libcurl documentation
* @param text
* @param stream
* @param ptr
* @param size
* @param nohex
*/
void dump(const char* text, FILE* stream, char* ptr, size_t size, char nohex) {
size_t i;
size_t c;
unsigned int width=0x10;
if(nohex)
/* without the hex output, we can fit more on screen */
width = 0x40;
fprintf(stream, "%s, %zd bytes (0x%zx)\n", text, size, size);
for(i=0; i<size; i+= width) {
fprintf(stream, "%04zx: ", i);
if(!nohex) {
/* hex not disabled, show it */
for(c = 0; c < width; c++) {
if(i+c < size)
fprintf(stream, "%02x ", ptr[i+c]);
else
fputs(" ", stream);
}
}
for(c = 0; (c < width) && (i+c < size); c++) {
/* check for 0D0A; if found, skip past and start a new line of output */
if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
i+=(c+2-width);
break;
}
fprintf(stream, "%c",(ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
i+=(c+3-width);
break;
}
}
fputc('\n', stream); /* newline */
}
fflush(stream);
}
/**
* This function is burrowed from the libcurl documentation
* @param handle
* @param type
* @param data
* @param size
* @param userp
* @return
*/
int my_trace(CURL* handle, curl_infotype type, char* data, size_t size, void* userp) {
struct config_data* config = (struct config_data *)userp;
const char* text;
(void)handle; /* prevent compiler warning */
switch (type) {
case CURLINFO_TEXT:
fprintf(stderr, "== Info: %s", data);
default: /* in case a new one is introduced to shock us */
return 0;
case CURLINFO_HEADER_OUT:
text = "=> Send header";
break;
case CURLINFO_DATA_OUT:
text = "=> Send data";
break;
case CURLINFO_SSL_DATA_OUT:
text = "=> Send SSL data";
break;
case CURLINFO_HEADER_IN:
text = "<= Recv header";
break;
case CURLINFO_DATA_IN:
text = "<= Recv data";
break;
case CURLINFO_SSL_DATA_IN:
text = "<= Recv SSL data";
break;
}
dump(text, stderr, data, size, config->trace_ascii);
return 0;
}
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @return void* to memory region
*/
static void* myrealloc(void* ptr, size_t size) {
/* There might be a realloc() out there that doesn't like reallocing
* NULL pointers, so we take care of it here
* */
if(ptr)
return realloc(ptr, size);
else
return malloc(size);
}
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @param nmemb
* @param data
* @return number of written bytes
*/
size_t WriteMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data) {
size_t realsize = size * nmemb;
struct MemoryStruct* mem = (struct MemoryStruct *)data;
mem->memory = (char *)myrealloc(mem->memory, mem->size + realsize + 1);
if (mem->memory) {
memcpy(&(mem->memory[mem->size]), ptr, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
}
return realsize;
}
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @param nmemb
* @param data
* @return number of written bytes
*/
size_t WriteHeaderCallback(void* ptr, size_t size, size_t nmemb, void* data) {
size_t realsize = size * nmemb;
struct MemoryStruct* mem = (struct MemoryStruct *)data;
mem->memory = (char *)myrealloc(mem->memory, mem->size + realsize + 1);
if (mem->memory) {
memcpy(&(mem->memory[mem->size]), ptr, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
}
return realsize;
}
/*
size_t ReadMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data){
struct MemoryStruct* mem = (struct MemoryStruct *)data;
memcpy(ptr, mem->memory, mem->size);
return mem->size;
}
*/
/**
* Initialize caldav settings structure.
* @param settings @see caldav_settings
*/
void init_caldav_settings(caldav_settings* settings) {
settings->username = NULL;
settings->password = NULL;
settings->url = NULL;
settings->file = NULL;
settings->usehttps = FALSE;
settings->custom_cacert = NULL;
settings->verify_ssl_certificate = TRUE;
settings->debug = FALSE;
settings->trace_ascii = TRUE;
settings->ACTION = UNKNOWN;
settings->start = 0;
settings->end = 0;
}
/**
* Free memory assigned to caldav settings structure.
* @param settings @see caldav_settings
*/
void free_caldav_settings(caldav_settings* settings) {
if (settings->username) {
g_free(settings->username);
settings->username = NULL;
}
if (settings->password) {
g_free(settings->password);
settings->password = NULL;
}
if (settings->url) {
g_free(settings->url);
settings->url = NULL;
}
if (settings->file) {
g_free(settings->file);
settings->file = NULL;
}
if (settings->custom_cacert) {
g_free(settings->custom_cacert);
settings->custom_cacert = NULL;
}
settings->verify_ssl_certificate = TRUE;
settings->usehttps = FALSE;
settings->debug = FALSE;
settings->trace_ascii = TRUE;
settings->ACTION = UNKNOWN;
settings->start = 0;
settings->end = 0;
}
static gchar* place_after_hostname(const gchar* start, const gchar* stop) {
gchar* newpos = NULL;
gchar* pos = (gchar *) stop;
gboolean digit = TRUE;
if (pos && stop && strcmp(start, pos) != 0) {
while (*pos != ':' && strcmp(start, pos) != 0)
--pos;
if (pos > start) {
gchar* tmp = (gchar *) pos + 1;
/* is pos++ a port number */
while (*tmp != '/' && digit) {
if (isdigit(*tmp) != 0) {
digit = TRUE;
tmp++;
}
else
digit = FALSE;
}
if (digit) {
/* pos was a port number */
while (*pos != '@' && strcmp(start, pos) != 0)
--pos;
if (strcmp(start, pos) != 0)
newpos = pos;
}
else {
while (*pos != '@' && pos != stop)
pos++;
if (pos != stop)
newpos = pos;
}
}
else {
/* is a username present */
gchar* tmp = NULL;
while (*pos != '/' && pos != stop) {
if (*pos == '@')
tmp = pos;
pos++;
}
if (tmp && pos != stop)
newpos = tmp;
}
}
return newpos;
}
/**
* Parse URL
* @param settings @see caldav_settings
* @param url String containing URL to collection
*/
void parse_url(caldav_settings* settings, const char* url) {
char* start;
char* pos;
char* end;
char* login;
login = pos = end = start = NULL;
if (!url)
return;
if ((pos = strstr(url, "//")) != NULL) {
/* Does the URL use https ?*/
if (!g_ascii_strncasecmp(url,"https",5) && settings->usehttps == FALSE) {
settings->usehttps=TRUE;
}
start = g_strdup(&(*(pos + 2)));
if ((pos = place_after_hostname(start, strrchr(start, '\0') - 1)) != NULL) {
/* username and/or password present */
login = g_strndup(start, pos - start);
end = pos;
if ((pos = strrchr(login, ':')) != NULL) {
/* both username and password is present */
settings->username = g_strndup(login, pos - login);
settings->password = g_strdup(++pos);
}
else {
/* only username present */
settings->username = g_strdup(login);
settings->password = NULL;
}
g_free(login);
settings->url = g_strdup(++end);
}
else {
/* no username or password present */
settings->url = g_strdup(start);
settings->username = NULL;
settings->password = NULL;
}
g_free(start);
}
}
/**
* Find a specific HTTP header from last request
* @param header HTTP header to search for
* @param headers String of HTTP headers from last request
* @param lowcase Should string be returned in all lower case.
* @return The header found or NULL
*/
#define MAX_TOKENS 2
gchar* get_response_header(
const char* header, gchar* headers, gboolean lowcase) {
gchar* line;
gchar* head = NULL;
gchar* oldhead = NULL;
gchar** buf;
gchar* header_list;
gchar* saveptr;
header_list = g_strdup(headers);
line = strtok_r(header_list, "\r\n", &saveptr);
if (line != NULL) {
do {
buf = g_strsplit(line, ":", MAX_TOKENS);
if (buf[1] != NULL) {
if (g_ascii_strcasecmp(buf[0], header) == 0) {
if (head) {
oldhead = head;
head = g_strconcat(head, ", ", buf[1], NULL);
g_free(oldhead);
}
else
head = g_strdup(buf[1]);
if (head)
g_strstrip(head);
}
}
g_strfreev(buf);
} while ((line = strtok_r(NULL, "\r\n", &saveptr)) != NULL);
}
g_free(header_list);
if (head)
return (lowcase) ? g_ascii_strdown(head, -1) : head;
else
return NULL;
}
static const char* VCAL_HEAD =
"BEGIN:VCALENDAR\r\n"
"PRODID:-//CalDAV Calendar//NONSGML libcaldav//EN\r\n"
"VERSION:2.0\r\n";
static const char* VCAL_FOOT = "END:VCALENDAR";
/**
* Parse response from CalDAV server. Internal function.
* @param report Response from server
* @param element XML element to find
* @param type VCalendar element to find
* @param wrap Is this the final parsing or just a part
* @param recursive Stop after first match or not
* @return the parsed result
*/
static gchar* parse_caldav_report_wrap(
char* report, const char* element, const char* type,
gboolean wrap, gboolean recursive) {
char* pos;
char* start;
char* object;
char* tmp_report;
char* tmp;
gchar* response;
gchar* begin_type;
gchar* end_type;
gboolean keep_going = TRUE;
begin_type = g_strdup_printf("BEGIN:%s", type);
end_type = g_strdup_printf("END:%s", type);
pos = start = object = response = NULL;
tmp_report = g_strdup(report);
while ((pos = strstr(tmp_report, element)) != NULL && keep_going) {
pos = strchr(pos, '>');
if (!pos) {
break;
}
pos = &(*(pos + 1));
pos = strstr(pos, begin_type);
if (!pos) {
break;
}
object = &(*(pos + strlen(begin_type)));
object = g_strchug(object);
start = g_strdup(object);
if ((pos = strstr(start, end_type)) == NULL) {
g_free(start);
break;
}
object = g_strndup(start, strlen(start) - strlen(pos));
if (response) {
tmp = g_strdup(response);
g_free(response);
response = g_strdup_printf("%s%s\r\n%s%s\r\n",
tmp, begin_type, object, end_type);
g_free(tmp);
}
else {
if (wrap)
response = g_strdup_printf("%s%s\r\n%s%s\r\n",
VCAL_HEAD, begin_type, object, end_type);
else
response = g_strdup_printf("%s\r\n%s%s\r\n",
begin_type, object, end_type);
}
if (recursive) {
pos = strchr(pos, '>');
g_free(tmp_report);
tmp_report = g_strdup(&(*(pos + 1)));
}
else {
keep_going = FALSE;
}
g_free(start);
g_free(object);
}
g_free(tmp_report);
g_free(begin_type);
g_free(end_type);
if (wrap)
if (response) {
object = g_strdup(response);
g_free(response);
response = g_strdup_printf("%s%s", object, VCAL_FOOT);
g_free(object);
}
return response;
}
/**
* Parse response from CalDAV server
* @param report Response from server
* @param element XML element to find
* @param type VCalendar element to find
* @return the parsed result
*/
gchar* parse_caldav_report(char* report, const char* element, const char* type) {
gchar* response = NULL;
gchar* timezone = NULL;
gchar* temp = NULL;
if (!report || !element || !type)
return NULL;
/* test for VTIMEZONE.
* Only the first found will be used and this will then
* be the time zone for the entire report
*/
timezone = parse_caldav_report_wrap(
report, element, "VTIMEZONE", FALSE, FALSE);
if (timezone) {
response = g_strdup_printf("%s%s", VCAL_HEAD, timezone);
g_free(timezone);
temp = parse_caldav_report_wrap(report, element, type, FALSE, TRUE);
if (temp) {
gchar* tmp = g_strdup(response);
g_free(response);
response = g_strdup_printf("%s%s%s", tmp, temp, VCAL_FOOT);
g_free(tmp);
g_free(temp);
}
else {
g_free(response);
return NULL;
}
}
else
response = parse_caldav_report_wrap(report, element, type, TRUE, TRUE);
return response;
}
/**
* Convert a time_t variable to CalDAV DateTime
* @param time a specific date and time
* @return the CalDAV DateTime
*/
gchar* get_caldav_datetime(time_t* time) {
struct tm *current;
gchar* datetime;
current = localtime(time);
datetime = g_strdup_printf("%d%.2d%.2dT%.2d%.2d%.2dZ",
current->tm_year + 1900, current->tm_mon + 1, current->tm_mday,
current->tm_hour, current->tm_min, current->tm_sec);
return datetime;
}
/**
* Create a random text string, using MD5. @see caldav_md5_hex_digest()
* @param text some text to randomize
* @return MD5 hash of text
*/
gchar* random_file_name(gchar* text) {
unsigned char* name;
gchar md5sum[33];
name = (unsigned char *) g_strdup(text);
caldav_md5_hex_digest(md5sum, name);
g_free(name);
return g_strdup(md5sum);
}
/**
* Does the event contain a UID element or not. If not add it.
* @param object A specific event
* @return event, eventually added UID
*/
gchar* verify_uid(gchar* object) {
gchar* uid;
gchar* newobj;
gchar* pos;
newobj = g_strdup(object);
uid = get_response_header("uid", object, TRUE);
if (!uid) {
object = g_strdup(newobj);
g_free(newobj);
pos = strstr(object, "END:VEVENT");
newobj = g_strndup(object, strlen(object) - strlen(pos));
newobj = g_strchomp(newobj);
uid = random_file_name(object);
gchar*tmp = g_strdup(newobj);
g_free(newobj);
newobj = g_strdup_printf("%s\r\nUID:libcaldav-%s@tempuri.org\r\n%s",
tmp, uid, pos);
g_free(uid);
g_free(tmp);
g_free(object);
}
else
g_free(uid);
/*uid = g_strdup(newobj);
g_free(newobj);*/
g_strchomp(newobj);
/*g_free(uid);*/
return newobj;
}
/**
* Fetch a URL from a XML element
* @param text String
* @return URL
*/
#define ELEM_HREF "href>"
gchar* get_url(gchar* text) {
gchar* pos;
gchar* url = NULL;
if ((pos = strstr(text, ELEM_HREF)) == NULL)
return url;
pos = &(*(pos + strlen(ELEM_HREF)));
url = g_strndup(pos, strlen(pos) - strlen(strchr(pos, '<')));
return url;
}
/**
* Fetch any element from XML
* @param text String
* @param tag The element to look for
* @return element
*/
gchar* get_tag(const gchar* tag, gchar* text) {
gchar *pos;
gchar* res = NULL;
gchar* the_tag = NULL;
/*printf("%s\n", text);*/
the_tag = g_strdup_printf("<%s>", tag);
if ((pos = strstr(text, the_tag)) == NULL) {
g_free(the_tag);
return res;
}
pos = &(*(pos + strlen(the_tag)));
res = g_strndup(pos, strlen(pos) - strlen(strchr(pos, '<')));
g_free(the_tag);
return res;
}
/**
* Fetch the etag element from XML
* @param text String
* @return etag
*/
#define ELEM_ETAG "getetag"
gchar* get_etag(gchar* text) {
gchar* etag = NULL;
etag = get_tag(ELEM_ETAG, text);
/* Maybe namespace prefixed */
if (!etag) {
etag = get_tag("D:getetag", text);
}
return etag;
}
/**
* Fetch host from URL
* @param url URL
* @return host
*/
gchar* get_host(gchar* url) {
gchar** buf;
gchar* result = NULL;
buf = g_strsplit(url, "/", 2);
if (buf[0]) {
result = g_strdup(buf[0]);
}
g_strfreev(buf);
return result;
}
/**
* rebuild a raw URL with https if needed from the settings
* @param settings caldav_settings
* @param uri URI to use instead of base
* @return URL
*/
gchar* rebuild_url(caldav_settings* settings, gchar* uri){
gchar* url = NULL;
gchar* mystr = NULL;
if (settings->usehttps) {
mystr = "https://";
} else {
mystr = "http://";
}
if (uri)
url = g_strdup_printf("%s%s", mystr, uri);
else
url = g_strdup_printf("%s%s", mystr,settings->url);
return url;
}
/**
* Prepare a curl connection
* @param settings caldav_settings
* @return CURL
*/
CURL* get_curl(caldav_settings* setting) {
CURL* curl;
gchar* userpwd = NULL;
gchar* url = NULL;
curl = curl_easy_init();
if (curl) {
if (setting->username) {
if (setting->password)
userpwd = g_strdup_printf("%s:%s",
setting->username, setting->password);
else
userpwd = g_strdup_printf("%s", setting->username);
curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd);
g_free(userpwd);
}
if (setting->verify_ssl_certificate)
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2);
else {
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
}
if (setting->custom_cacert)
curl_easy_setopt(curl, CURLOPT_CAINFO, setting->custom_cacert);
curl_easy_setopt(curl, CURLOPT_USERAGENT, __CALDAV_USERAGENT);
url = rebuild_url(setting, NULL);
curl_easy_setopt(curl, CURLOPT_URL, url);
g_free(url);
}
return (curl) ? curl : NULL;
}

221
src/.svn/text-base/caldav-utils.h.svn-base
Unescape View File

@ -0,0 +1,221 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __CALDAV_UTILS_H__
#define __CALDAV_UTILS_H__
#include <glib.h>
#include <stdlib.h>
#include <curl/curl.h>
#include "caldav.h"
/**
* @typedef struct _CALDAV_SETTINGS caldav_settings
* A pointer to a struct _CALDAV_SETTINGS
*/
typedef struct _CALDAV_SETTINGS caldav_settings;
/**
* @struct _CALDAV_SETTINGS
* A struct used to exchange all user input between various parts
* of the library
*/
struct _CALDAV_SETTINGS {
gchar* username;
gchar* password;
gchar* url;
gchar* file;
gboolean usehttps;
gboolean verify_ssl_certificate;
gchar* custom_cacert;
gboolean debug;
gboolean use_locking;
char trace_ascii;
CALDAV_ACTION ACTION;
time_t start;
time_t end;
};
/**
* @typedef struct MemoryStruct memory_ptr
* A pointer to a struct MemoryStruct
*/
typedef struct MemoryStruct memory_ptr;
/**
* @struct MemoryStruct
* Used to hold messages between the CalDAV server and the library
*/
struct MemoryStruct {
char *memory;
size_t size;
};
/** @struct config_data
* Used to exchange user options to the library
*/
struct config_data {
char trace_ascii;
};
/**
* This function is burrowed from the libcurl documentation
* @param text
* @param stream
* @param ptr
* @param size
* @param nohex
*/
void dump(const char* text, FILE* stream, char* ptr, size_t size, char nohex);
/**
* This function is burrowed from the libcurl documentation
* @param handle
* @param type
* @param data
* @param size
* @param userp
* @return
*/
int my_trace(CURL* handle, curl_infotype type, char* data, size_t size, void* userp);
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @return void* to memory region
*/
size_t WriteMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data);
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @param nmemb
* @param data
* @return number of written bytes
*/
size_t WriteHeaderCallback(void* ptr, size_t size, size_t nmemb, void* data);
/*size_t ReadMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data);*/
/**
* Initialize caldav settings structure.
* @param settings @see caldav_settings
*/
void init_caldav_settings(caldav_settings* settings);
/**
* Free momory assigned to caldav settings structure.
* @param settings @see caldav_settings
*/
void free_caldav_settings(caldav_settings* settings);
/**
* Parse URL
* @param settings @see caldav_settings
* @param url String containing URL to collection
*/
void parse_url(caldav_settings* settings, const char* url);
/**
* Find a specific HTTP header from last request
* @param header HTTP header to search for
* @param headers String of HTTP headers from last request
* @param lowcase Should string be returned in all lower case.
* @return The header found or NULL
*/
gchar* get_response_header(
const char* header, gchar* headers, gboolean lowcase);
/**
* Parse response from CalDAV server
* @param report Response from server
* @param element XML element to find
* @param type VCalendar element to find
* @return the parsed result
*/
gchar* parse_caldav_report(char* report, const char* element, const char* type);
/**
* Convert a time_t variable to CalDAV DateTime
* @param time a specific date and time
* @return the CalDAV DateTime
*/
gchar* get_caldav_datetime(time_t* time);
/**
* Create a random text string, using MD5. @see caldav_md5_hex_digest()
* @param text some text to randomize
* @return MD5 hash of text
*/
gchar* random_file_name(gchar* text);
/**
* Does the event contain a UID element or not. If not add it.
* @param object A specific event
* @return event, eventually added UID
*/
gchar* verify_uid(gchar* object);
/**
* Fetch a URL from a XML element
* @param text String
* @return URL
*/
gchar* get_url(gchar* text);
/**
* Fetch host from URL
* @param url URL
* @return host
*/
gchar* get_host(gchar* url);
/**
* Fetch the etag element from XML
* @param text String
* @return etag
*/
gchar* get_etag(gchar* text);
/**
* Fetch any element from XML
* @param text String
* @return element
*/
gchar* get_tag(const gchar* tag, gchar* text);
/**
* rebuild a raw URL with https if needed from the settings
* @param settings caldav_settings
* @return URL
*/
gchar* rebuild_url(caldav_settings* setting, gchar* uri);
/**
* Prepare a curl connection
* @param settings caldav_settings
* @return CURL
*/
CURL* get_curl(caldav_settings* setting);
#endif

745
src/.svn/text-base/caldav.c.svn-base
Unescape View File

@ -0,0 +1,745 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "caldav.h"
#include "caldav-utils.h"
#include "get-caldav-report.h"
#include "add-caldav-object.h"
#include "delete-caldav-object.h"
#include "modify-caldav-object.h"
#include "get-display-name.h"
#include "options-caldav-server.h"
#include "get-freebusy-report.h"
#include <curl/curl.h>
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void init_runtime(runtime_info* info) {
if (! info)
return;
if (! info->error)
info->error = g_new0(caldav_error, 1);
if (! info->options) {
info->options = g_new0(debug_curl, 1);
info->options->trace_ascii = 1;
info->options->debug = 0;
info->options->verify_ssl_certificate = TRUE;
info->options->use_locking = TRUE;
info->options->custom_cacert = NULL;
}
}
/**
* @param curl An instance of libcurl.
* @param settings Defines CalDAV resource. Receiver is responsible for freeing
* the memory. URL is part of the structure. [http://][username:password@]host[:port]/url-path.
* See (RFC1738).
* @return FALSE (zero) mens URL does not reference a CalDAV calendar
* resource. TRUE if the URL does reference a CalDAV calendar resource.
*/
static gboolean test_caldav_enabled(CURL* curl,
caldav_settings* settings,
caldav_error* error) {
return caldav_getoptions(curl, settings, NULL, error, TRUE);
}
/*
* @param settings An instance of caldav_settings. @see caldav_settings
* @return TRUE if there was an error. Error can be in libcurl, in libcaldav,
* or an error related to the CalDAV protocol.
*/
static gboolean make_caldav_call(caldav_settings* settings,
runtime_info* info) {
CURL* curl;
gboolean result = FALSE;
g_return_val_if_fail(info != NULL, TRUE);
curl = get_curl(settings);
if (!curl) {
info->error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
if (!test_caldav_enabled(curl, settings, info->error)) {
g_free(settings->file);
settings->file = NULL;
curl_easy_cleanup(curl);
return TRUE;
}
curl_easy_cleanup(curl);
switch (settings->ACTION) {
case GETALL: result = caldav_getall(settings, info->error); break;
case GET: result = caldav_getrange(settings, info->error); break;
case ADD: result = caldav_add(settings, info->error); break;
case DELETE: result = caldav_delete(settings, info->error); break;
case MODIFY: result = caldav_modify(settings, info->error); break;
case GETCALNAME: result = caldav_getname(settings, info->error); break;
case FREEBUSY: result = caldav_freebusy(settings, info->error); break;
default: break;
}
return result;
}
/**
* Function for adding a new event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_add_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = ADD;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for deleting an event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_delete_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = DELETE;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for modifying an event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_modify_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = MODIFY;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for getting a collection of events determined by time range.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start and end for range. Both
* are included in range.
* @param end time_t variable specifying start and end for range. Both
* are included in range.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_object(response *result,
time_t start,
time_t end,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = GET;
settings.start = start;
settings.end = end;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for getting all events from the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_getall_object(response* result,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = GETALL;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for getting the stored display name for the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_displayname(response* result,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = GETCALNAME;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function to test wether a calendar resource is CalDAV enabled or not.
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @result 0 (zero) means no CalDAV support, otherwise CalDAV support
* detechted.
*/
int caldav_enabled_resource(const char* URL, runtime_info* info) {
CURL* curl;
caldav_settings settings;
struct config_data data;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
parse_url(&settings, URL);
curl = get_curl(&settings);
if (!curl) {
info->error->code = -1;
info->error->str = g_strdup("Could not initialize libcurl");
settings.file = NULL;
return TRUE;
}
if (info->options->trace_ascii)
data.trace_ascii = 1;
else
data.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
if (info->options->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gboolean res = test_caldav_enabled(curl, &settings, info->error);
free_caldav_settings(&settings);
curl_easy_cleanup(curl);
return (res && (info->error->code == 0 || info->error->code == 200)) ? 1 : 0;
}
/**
* Function for getting free/busy information.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start and end for range. Both
* are included in range.
* @param end time_t variable specifying start and end for range. Both
* are included in range.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_freebusy(response *result,
time_t start,
time_t end,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = FREEBUSY;
settings.start = start;
settings.end = end;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function which supports sending various options inside the library.
* @param curl_options A struct debug_curl. See debug_curl.
*/
void caldav_set_options(debug_curl curl_options) {
}
/**
* @deprecated Function to call in case of errors.
* Caller provides a pointer to a local caldav_error structure.
* Caldav_get_error will initialize pointer if NULL.
* Caller is responsible for freeing returned memory.
* After the first call the internal error buffer is reset.
* @param lib_error A pointer to a struct _caldav_error. @see _caldav_error
* @return An initialized caldav_error pointer to memory where error
* messages can be found from the last call to the library.
*/
caldav_error* caldav_get_error(caldav_error* lib_error) {
if (!lib_error) {
lib_error = g_new0(caldav_error, 1);
}
return lib_error;
}
/**
* Function for freeing memory for a previous initialization of a
* caldav_error. @see caldav_get_error()
* Caller provides a pointer to a local caldav_error structure.
* @param lib_error A pointer to a struct _caldav_error. @see _caldav_error
*/
void caldav_free_error(caldav_error* lib_error) {
if (lib_error->str)
g_free(lib_error->str);
g_free(lib_error);
lib_error = NULL;
}
/**
* Function to call to get a list of supported CalDAV options for a server
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @result A list of available options or NULL in case of any error.
*/
char** caldav_get_server_options(const char* URL, runtime_info* info) {
CURL* curl;
caldav_settings settings;
response server_options;
gchar** option_list = NULL;
gchar** tmp;
gboolean res = FALSE;
g_return_val_if_fail(info != NULL, NULL);
init_runtime(info);
tmp = option_list = NULL;
init_caldav_settings(&settings);
parse_url(&settings, URL);
curl = get_curl(&settings);
if (!curl) {
info->error->code = -1;
info->error->str = g_strdup("Could not initialize libcurl");
settings.file = NULL;
return NULL;
}
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
res = caldav_getoptions(curl, &settings, &server_options, info->error, FALSE);
if (res) {
if (server_options.msg) {
option_list = g_strsplit(server_options.msg, ", ", 0);
tmp = &(*(option_list));
while (*tmp) {
g_strstrip(*tmp++);
}
}
}
free_caldav_settings(&settings);
curl_easy_cleanup(curl);
return (option_list) ? option_list : NULL;
}
/**
* Function for getting an initialized runtime_info structure
* @return runtime_info. @see runtime_info
*/
runtime_info* caldav_get_runtime_info() {
runtime_info* rt_info;
rt_info = g_new0(runtime_info, 1);
rt_info->error = g_new0(caldav_error, 1);
rt_info->options = g_new0(debug_curl, 1);
return rt_info;
}
/**
* Function for freeing memory for a previous initialization of an info
* structure
* @param info Address to a pointer to a runtime_info structure. @see
* runtime_info
*/
void caldav_free_runtime_info(runtime_info** info) {
runtime_info* ri;
if (*info) {
ri = *info;
if (ri->error) {
if (ri->error->str)
g_free(ri->error->str);
g_free(ri->error);
ri->error = NULL;
}
if (ri->options) {
if (ri->options->custom_cacert)
g_free(ri->options->custom_cacert);
g_free(ri->options);
ri->options = NULL;
}
g_free(ri);
*info = ri = NULL;
}
}
/**
* Function for getting an initialized response structure
* @return response. @see _response
*/
response* caldav_get_response() {
response* r;
r = g_new0(response, 1);
return r;
}
/**
* Function for freeing memory for a previous initialization of an response
* structure
* @param info Address to a pointer to a response structure. @see
* _response
*/
void caldav_free_response(response** resp) {
response* r;
if (*resp) {
r = *resp;
if (r->msg)
g_free(r->msg);
g_free(r);
*resp = r = NULL;
}
}

343
src/.svn/text-base/caldav.h.svn-base
Unescape View File

@ -0,0 +1,343 @@
/* vim: set textwidth=80 tabstop=4: */
/**
* @file caldav.h
* @brief interface to the caldav library.
* The library conforms to RFC4791. For further information follow this
* link http://www.ietf.org/rfc/rfc4791.txt
*/
/**
* @mainpage
* This document is the documentation for the public interface to libcaldav.
* If you want to study the implementation look for the developers API.
*
* The libray and documentation is Copyright (c) 2008 Michael Rasmussen
* (mir@datanom.net)
*
* License for the source code.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* License for the documentation.
*
* Permission is granted to copy, distribute and/or modify this document
* under the terms of the GNU Free Documentation License, Version 1.2
* or any later version published by the Free Software Foundation;
* with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
* Texts.
*/
#ifndef __CALDAV_H__
#define __CALDAV_H__
#include <time.h>
/* For debug purposes */
/**
* @typedef struct debug_curl
* A struct used to set internal options in the library
*/
typedef struct {
int trace_ascii; /** @var int trace_ascii
* 0 or 1
*/
int debug; /** @var int debug
* 0 or 1
*/
int verify_ssl_certificate;
int use_locking;
char* custom_cacert;
} debug_curl;
/**
* @typedef struct _caldav_error caldav_error
* Pointer to a caldav_error structure
*/
typedef struct _caldav_error caldav_error;
/**
* @struct _caldav_error
* A struct for storing error codes and messages
*/
struct _caldav_error {
long code; /**
* @var long code
* if < 0 internal error > 0 CalDAV protocol error.
*/
char* str; /** @var char* str
* For storing human readable error message
*/
};
/**
* @typedef struct runtime_info
* Pointer to a runtime structure holding debug and error information
*/
typedef struct {
caldav_error* error;
debug_curl* options;
} runtime_info;
/* CalDAV is defined in RFC4791 */
/* Buffer to hold response */
/**
* @typedef struct _response response
* Pointer to a _response structure
*/
typedef struct _response response;
/**
* @struct _response
* A struct used for returning messages from the library to users
*/
struct _response {
char* msg; /** @var char* msg
* String for storing response
*/
};
/**
* @enum CALDAV_ACTION specifies supported CalDAV actions.
* UNKNOWN. An unknown action.
* ADD. Add a CalDAV calendar object.
* DELETE. Delete a CalDAV calendar object.
* MODIFY. Modify a CalDAV calendar object.
* GET. Get one or more CalDAV calendar object(s).
* GETALL. Get all CalDAV calendar objects.
*/
typedef enum {
UNKNOWN,
ADD,
DELETE,
FREEBUSY,
MODIFY,
GET,
GETALL,
GETCALNAME,
ISCALDAV,
OPTIONS
} CALDAV_ACTION;
/**
* @enum CALDAV_RESPONSE specifies CalDAV error states.
* OK (HTTP 200). Request was satisfied.
* FORBIDDEN (HTTP 403). Access not allowed. Dont repeat request.
* CONFLICT (HTTP 409). Conflict between current state of CalDAV collection
* and request. Client must solve the conflict and then resend request.
* LOCKED (HTTP 423). Locking failed.
*/
typedef enum {
OK,
FORBIDDEN,
CONFLICT,
LOCKED,
NOTIMPLEMENTED
} CALDAV_RESPONSE;
#ifndef __CALDAV_USERAGENT
#define __CALDAV_USERAGENT "libcurl-agent/0.1"
#endif
/**
* Function for adding a new event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_add_object(const char* object,
const char* URL,
runtime_info* info);
/**
* Function for deleting an event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_delete_object(const char* object,
const char* URL,
runtime_info* info);
/**
* Function for modifying an event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_modify_object(const char* object,
const char* URL,
runtime_info* info);
/**
* Function for getting a collection of events determined by time range.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start for range. Included in search.
* @param end time_t variable specifying end for range. Included in search.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_object(response* result,
time_t start,
time_t end,
const char* URL,
runtime_info* info);
/**
* Function for getting all events from the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_getall_object(response* result,
const char* URL,
runtime_info* info);
/**
* Function for getting the stored display name for the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_displayname(response* result,
const char* URL,
runtime_info* info);
/**
* Function to test wether a calendar resource is CalDAV enabled or not.
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @result 0 (zero) means no CalDAV support, otherwise CalDAV support
* detechted.
*/
int caldav_enabled_resource(const char* URL, runtime_info* info);
/**
* Function for getting free/busy information.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start and end for range. Both
* are included in range.
* @param end time_t variable specifying start and end for range. Both
* are included in range.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_freebusy(response *result,
time_t start,
time_t end,
const char* URL,
runtime_info* info);
/**
* @deprecated Always returns an initialized empty caldav_error
* Function to call in case of errors.
* Caller provides a pointer to a local caldav_error structure.
* Caldav_get_error will initialize pointer if NULL.
* Caller is responsible for freeing returned memory.
* After the first call the internal error buffer is reset.
* @param lib_error A pointer to a struct _caldav_error. @see _caldav_error
* @return An initialized caldav_error pointer to memory where error
* messages can be found from the last call to the library.
*/
caldav_error* caldav_get_error(caldav_error* lib_error);
/**
* Function for freeing memory for a previous initialization of a
* caldav_error. @see caldav_get_error()
* Caller provides a pointer to a local caldav_error structure.
* @param lib_error A pointer to a struct _caldav_error. @see _caldav_error
*/
void caldav_free_error(caldav_error* lib_error);
/* Setting various options in library */
/**
* @deprecated Does nothing
* Function which supports sending various options inside the library.
* @param curl_options A struct debug_curl. See debug_curl.
*/
void caldav_set_options(debug_curl curl_options);
/**
* Function to call to get a list of supported CalDAV options for a server
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @result A list of available options or NULL in case of any error.
*/
char** caldav_get_server_options(const char* URL, runtime_info* info);
/**
* Function for getting an initialized runtime_info structure
* @return runtime_info. @see runtime_info
*/
runtime_info* caldav_get_runtime_info();
/**
* Function for freeing memory for a previous initialization of an info
* structure
* @param info Address to a pointer to a runtime_info structure. @see
* runtime_info
*/
void caldav_free_runtime_info(runtime_info** info);
/**
* Function for getting an initialized response structure
* @return response. @see _response
*/
response* caldav_get_response();
/**
* Function for freeing memory for a previous initialization of an response
* structure
* @param info Address to a pointer to a response structure. @see
* _response
*/
void caldav_free_response(response** info);
#endif

284
src/.svn/text-base/delete-caldav-object.c.svn-base
Unescape View File

@ -0,0 +1,284 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "delete-caldav-object.h"
#include "lock-caldav-object.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the first part of the calendar query.
* The actual UID to use for the query is added at runtime.
*/
static char* search_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VEVENT\">"
" <C:prop-filter name=\"UID\">";
/**
* A static literal string containing the last part of the calendar query
*/
static char* search_tail =
"</C:prop-filter>"
" </C:comp-filter>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>";
/**
* Function for deleting an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_delete(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* search;
gchar* uid;
gboolean LOCKSUPPORT = FALSE;
gchar* lock_token = NULL;
gboolean result = FALSE;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: infinity");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* file = g_strdup(settings->file);
if ((uid = get_response_header("uid", file, FALSE)) == NULL) {
g_free(file);
error->code = 1;
error->str = g_strdup("Error: Missing required UID for object");
return TRUE;
}
g_free(file);
/*
* ICalendar server does not support collation
* <C:text-match collation=\"i;ascii-casemap\">%s</C:text-match>
*/
search = g_strdup_printf(
"%s\r\n<C:text-match>%s</C:text-match>\r\n%s",
search_head, uid, search_tail);
g_free(uid);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, search);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(search));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
g_free(search);
curl_slist_free_all(http_header);
http_header = NULL;
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
else {
/* enable uploading */
gchar* url = NULL;
gchar* etag = NULL;
url = get_url(chunk.memory);
if (url) {
etag = get_etag(chunk.memory);
if (etag) {
gchar* host = get_host(settings->url);
if (host) {
file = g_strdup(url);
g_free(url);
url = g_strdup_printf("%s%s", host, file);
g_free(file);
g_free(host);
}
else {
g_free(etag);
g_free(url);
url = NULL;
}
}
else {
g_free(url);
url = NULL;
}
}
if (url) {
int lock = 0;
caldav_error lock_error;
file = g_strdup(etag);
g_free(etag);
etag = g_strdup_printf("If-Match: %s", file);
g_free(file);
http_header = curl_slist_append(http_header, etag);
g_free(etag);
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(
http_header, "Transfer-Encoding:");
if (settings->use_locking)
LOCKSUPPORT = caldav_lock_support(settings, &lock_error);
else
LOCKSUPPORT = FALSE;
if (LOCKSUPPORT) {
lock_token = caldav_lock_object(url, settings, &lock_error);
if (lock_token) {
http_header = curl_slist_append(
http_header, g_strdup_printf(
"If: (%s)", lock_token));
}
/*
* If error code is 423 (Resource is LOCKED) bail out
*/
else if (lock_error.code == 423) {
lock = -1;
}
/*
* If error code is 501 (Not implemented) we continue
* hoping for the best.
*/
else if (lock_error.code == 501) {
lock_token = g_strdup("");
}
else {
lock = -1;
}
}
if (! LOCKSUPPORT || (LOCKSUPPORT && lock_token && lock_error.code != 423)) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_URL, rebuild_url(settings, url));
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, 0);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (LOCKSUPPORT && lock_token) {
caldav_unlock_object(
lock_token, url, settings, &lock_error);
}
}
g_free(url);
g_free(lock_token);
if (res != 0 || lock < 0) {
/* Is this a lock_error don't change error*/
if (lock == 0 || lock_error.code == 423) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
error->code = lock_error.code;
error->str = g_strdup(lock_error.str);
}
result = TRUE;
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(
curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
}
curl_slist_free_all(http_header);
}
else {
error->code = code;
if (chunk.memory)
error->str = g_strdup(chunk.memory);
else
error->str = g_strdup("No object found");
result = TRUE;
}
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}

35
src/.svn/text-base/delete-caldav-object.h.svn-base
Unescape View File

@ -0,0 +1,35 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __DELETE_CALDAV_OBJECT_H__
#define __DELETE_CALDAV_OBJECT_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function for deleting an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_delete(caldav_settings* settings, caldav_error* error);
#endif

254
src/.svn/text-base/get-caldav-report.c.svn-base
Unescape View File

@ -0,0 +1,254 @@
/* vim: set textwidth=80 tabstop=4 smarttab: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "get-caldav-report.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the calendar query for fetching
* all events from collection.
*/
static const char* getall_request =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VEVENT\"/>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>\r\n";
/**
* A static literal string containing the first part of the calendar query.
* The actual VEVENT to search for is added at runtime.
*/
static const char* getrange_request_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
/*"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"*/
"<C:calendar-query xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop xmlns:D=\"DAV:\">"
/*" <D:getetag/>"*/
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VEVENT\">";
/**
* A static literal string containing the last part of the calendar query
*/
static const char* getrange_request_foot =
" </C:comp-filter>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>\r\n";
/**
* Function for getting all events from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getall(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, getall_request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(getall_request));
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(headers.memory);
result = TRUE;
}
else {
gchar* report;
report = parse_caldav_report(
chunk.memory, "calendar-data", "VEVENT");
settings->file = g_strdup(report);
g_free(report);
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}
/**
* Function for getting all events within a time range from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getrange(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE + 1];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
gchar* request = NULL;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
request = g_strdup_printf(
"%s\r\n<C:time-range start=\"%s\"\r\n end=\"%s\"/>\r\n%s",
getrange_request_head, get_caldav_datetime(&settings->start),
get_caldav_datetime(&settings->end), getrange_request_foot);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(request));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
gchar* report;
report = parse_caldav_report(chunk.memory, "calendar-data", "VEVENT");
settings->file = g_strdup(report);
g_free(report);
}
g_free(request);
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}

43
src/.svn/text-base/get-caldav-report.h.svn-base
Unescape View File

@ -0,0 +1,43 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GET_CALDAV_REPORT_H__
#define __GET_CALDAV_REPORT_H__
#include "caldav-utils.h"
#include "caldav.h"
#include <glib.h>
/**
* Function for getting all events from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getall(caldav_settings* settings, caldav_error* error);
/**
* Function for getting all events within a time range from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getrange(caldav_settings* settings, caldav_error* error);
#endif

138
src/.svn/text-base/get-display-name.c.svn-base
Unescape View File

@ -0,0 +1,138 @@
/* vim: set textwidth=80 tabstop=4 smarttab: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "get-caldav-report.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the calendar query for fetching
* the stored display name for the collection.
*/
static const char* getname_request =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<D:propfind xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:displayname/>"
" </D:prop>"
"</D:propfind>\r\n";
/**
* Function for getting the display name from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getname(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 0");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, getname_request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(getname_request));
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PROPFIND");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(headers.memory);
result = TRUE;
}
else {
gchar* displayname;
displayname = get_tag("displayname", chunk.memory);
/* Maybe namespace prefixed */
if (!displayname) {
displayname = get_tag("D:displayname", chunk.memory);
}
settings->file = (displayname) ?
g_strdup(displayname) : g_strdup("");
g_free(displayname);
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}

34
src/.svn/text-base/get-display-name.h.svn-base
Unescape View File

@ -0,0 +1,34 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GET_DISPLAY_NAME_H__
#define __GET_DISPLAY_NAME_H__
#include "caldav-utils.h"
/**
* Function for getting the display name from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getname(caldav_settings* settings, caldav_error* error);
#endif

292
src/.svn/text-base/lock-caldav-object.c.svn-base
Unescape View File

@ -0,0 +1,292 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "lock-caldav-object.h"
#include "options-caldav-server.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the lock query.
*/
static char* lock_query =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<D:lockinfo xmlns:D=\"DAV:\">"
" <D:lockscope><D:exclusive/></D:lockscope>"
" <D:locktype><D:write/></D:locktype>"
"</D:lockinfo>";
/**
* Function which requests a lock on a calendar resource
* @param URI The resource to request lock on.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return The Lock-Token or NULL in case of error
*/
gchar* caldav_lock_object(
gchar* URI, caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* lock_token = NULL;
gchar* url;
if (! caldav_lock_support(settings, error))
return lock_token;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return lock_token;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Timeout: Second-300");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
if (settings->usehttps) {
url = g_strdup_printf("https://%s", URI);
} else {
url = g_strdup_printf("http://%s", URI);
}
curl_easy_setopt(curl, CURLOPT_URL, url);
g_free(url);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, lock_query);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(lock_query));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "LOCK");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
curl_slist_free_all(http_header);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 200) {
gchar* status = get_tag("status", chunk.memory);
if (status && strstr(status, "423") != NULL) {
error->code = 423;
error->str = g_strdup(status);
}
else {
error->code = code;
error->str = g_strdup(chunk.memory);
}
g_free(status);
}
else {
lock_token = get_response_header(
"Lock-Token", headers.memory, FALSE);
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return lock_token;
}
/**
* Function which requests to have a lock removed from a calendar resource
* @param lock_token A privious aquired Lock-Token
* @param URI The resource to request unlock on.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return False in case the lock could not be removed. True otherwise.
*/
gboolean caldav_unlock_object(gchar* lock_token, gchar* URI,
caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
gchar* url;
if (! caldav_lock_support(settings, error))
return result;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
g_strdup_printf("Lock-Token: %s", lock_token));
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
if (settings->usehttps) {
url = g_strdup_printf("https://%s", URI);
} else {
url = g_strdup_printf("http://%s", URI);
}
curl_easy_setopt(curl, CURLOPT_URL, url);
g_free(url);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "UNLOCK");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
curl_slist_free_all(http_header);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
result = TRUE;
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}
/**
* Function to test whether the server supports locking or not. Searching
* for PROP LOCK. If LOCK is present then according to RFC4791 PROP UNLOCK
* must also be present.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return True if locking is supported by the server. False otherwise
*/
gboolean caldav_lock_support(caldav_settings* settings, caldav_error* error) {
gboolean found = FALSE;
gchar* url = NULL;
gchar* mystr = NULL;
runtime_info* info;
info = caldav_get_runtime_info();
info->options->verify_ssl_certificate = settings->verify_ssl_certificate;
info->options->custom_cacert = g_strdup(settings->custom_cacert);
if (settings->usehttps) {
mystr = g_strdup("https://");
} else {
mystr = g_strdup("http://");
}
if (settings->username && settings->password) {
url = g_strdup_printf("%s%s:%s@%s",
mystr, settings->username, settings->password, settings->url);
}
else if (settings->username) {
url = g_strdup_printf("%s%s@%s",
mystr, settings->username, settings->url);
}
else {
url = g_strdup_printf("%s%s", mystr, settings->url);
}
gchar** options = caldav_get_server_options(url, info);
g_free(url);
gchar** tmp = options;
caldav_free_runtime_info(&info);
while (*options) {
if (strcmp(*options++, "LOCK") == 0) {
found = TRUE;
break;
}
}
g_strfreev(tmp);
g_free(mystr);
return found;
}

55
src/.svn/text-base/lock-caldav-object.h.svn-base
Unescape View File

@ -0,0 +1,55 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __LOCK_CALDAV_OBJECT_H__
#define __LOCK_CALDAV_OBJECT_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function which requests a lock on a calendar resource
* @param URI The resource to request lock on.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return The Lock-Token or NULL in case of error
*/
gchar* caldav_lock_object(
gchar* URI, caldav_settings* settings, caldav_error* error);
/**
* Function which requests to have a lock removed from a calendar resource
* @param lock_token A privious aquired Lock-Token
* @param URI The resource to request unlock on.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return False in case the lock could not be removed. True otherwise.
*/
gboolean caldav_unlock_object(gchar* lock_token, gchar* URI,
caldav_settings* settings, caldav_error* error);
/**
* Function to test whether the server supports locking or not
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return True if locking is supported by the server. False otherwise
*/
gboolean caldav_lock_support(caldav_settings* settings, caldav_error* error);
#endif

442
src/.svn/text-base/md5.c.svn-base
Unescape View File

@ -0,0 +1,442 @@
/** md5.c - MD5 Message-Digest Algorithm
* Copyright (C) 1995, 1996, 1998, 1999 Free Software Foundation, Inc.
*
* according to the definition of MD5 in RFC 1321 from April 1992.
* NOTE: This is *not* the same file as the one from glibc.
*
* 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, 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 <http://www.gnu.org/licenses/>.
*
* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
* heavily modified for GnuPG by <werner.koch@guug.de>.
* modified again for Sylpheed by <wk@gnupg.org> 2001-02-11.
*/
/* Test values:
* "" D4 1D 8C D9 8F 00 B2 04 E9 80 09 98 EC F8 42 7E
* "a" 0C C1 75 B9 C0 F1 B6 A8 31 C3 99 E2 69 77 26 61
* "abc 90 01 50 98 3C D2 4F B0 D6 96 3F 7D 28 E1 7F 72
* "message digest" F9 6B 69 7D 7C B7 93 8D 52 5A 2F 31 AA F1 61 D0
*/
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "md5.h"
/****************
* Rotate a 32 bit integer by n bytes
*/
#if defined(__GNUC__) && defined(__i386__)
static inline u32
rol( u32 x, int n)
{
__asm__("roll %%cl,%0"
:"=r" (x)
:"0" (x),"c" (n));
return x;
}
#else
#define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) )
#endif
static void
md5_init(MD5_CONTEXT *ctx)
{
ctx->A = 0x67452301;
ctx->B = 0xefcdab89;
ctx->C = 0x98badcfe;
ctx->D = 0x10325476;
ctx->nblocks = 0;
ctx->count = 0;
ctx->finalized = 0;
}
/* These are the four functions used in the four steps of the MD5 algorithm
and defined in the RFC 1321. The first function is a little bit optimized
(as found in Colin Plumbs public domain implementation). */
/* #define FF(b, c, d) ((b & c) | (~b & d)) */
#define FF(b, c, d) (d ^ (b & (c ^ d)))
#define FG(b, c, d) FF (d, b, c)
#define FH(b, c, d) (b ^ c ^ d)
#define FI(b, c, d) (c ^ (b | ~d))
/****************
* transform n*64 bytes
*/
static void
transform(MD5_CONTEXT *ctx, const unsigned char *data)
{
u32 correct_words[16];
u32 A = ctx->A;
u32 B = ctx->B;
u32 C = ctx->C;
u32 D = ctx->D;
u32 *cwp = correct_words;
#ifdef BIG_ENDIAN_HOST
{
int i;
unsigned char *p2;
const unsigned char *p1;
for (i = 0, p1 = data, p2 = (unsigned char*)correct_words;
i < 16; i++, p2 += 4) {
p2[3] = *p1++;
p2[2] = *p1++;
p2[1] = *p1++;
p2[0] = *p1++;
}
}
#else
memcpy(correct_words, data, 64);
#endif
#define OP(a, b, c, d, s, T) \
do { \
a += FF (b, c, d) + (*cwp++) + T; \
a = rol(a, s); \
a += b; \
} while (0)
/* Before we start, one word about the strange constants.
They are defined in RFC 1321 as
T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
*/
/* Round 1. */
OP (A, B, C, D, 7, 0xd76aa478);
OP (D, A, B, C, 12, 0xe8c7b756);
OP (C, D, A, B, 17, 0x242070db);
OP (B, C, D, A, 22, 0xc1bdceee);
OP (A, B, C, D, 7, 0xf57c0faf);
OP (D, A, B, C, 12, 0x4787c62a);
OP (C, D, A, B, 17, 0xa8304613);
OP (B, C, D, A, 22, 0xfd469501);
OP (A, B, C, D, 7, 0x698098d8);
OP (D, A, B, C, 12, 0x8b44f7af);
OP (C, D, A, B, 17, 0xffff5bb1);
OP (B, C, D, A, 22, 0x895cd7be);
OP (A, B, C, D, 7, 0x6b901122);
OP (D, A, B, C, 12, 0xfd987193);
OP (C, D, A, B, 17, 0xa679438e);
OP (B, C, D, A, 22, 0x49b40821);
#undef OP
#define OP(f, a, b, c, d, k, s, T) \
do { \
a += f (b, c, d) + correct_words[k] + T; \
a = rol(a, s); \
a += b; \
} while (0)
/* Round 2. */
OP (FG, A, B, C, D, 1, 5, 0xf61e2562);
OP (FG, D, A, B, C, 6, 9, 0xc040b340);
OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
OP (FG, A, B, C, D, 5, 5, 0xd62f105d);
OP (FG, D, A, B, C, 10, 9, 0x02441453);
OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
OP (FG, A, B, C, D, 9, 5, 0x21e1cde6);
OP (FG, D, A, B, C, 14, 9, 0xc33707d6);
OP (FG, C, D, A, B, 3, 14, 0xf4d50d87);
OP (FG, B, C, D, A, 8, 20, 0x455a14ed);
OP (FG, A, B, C, D, 13, 5, 0xa9e3e905);
OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8);
OP (FG, C, D, A, B, 7, 14, 0x676f02d9);
OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
/* Round 3. */
OP (FH, A, B, C, D, 5, 4, 0xfffa3942);
OP (FH, D, A, B, C, 8, 11, 0x8771f681);
OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
OP (FH, A, B, C, D, 1, 4, 0xa4beea44);
OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9);
OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60);
OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
OP (FH, A, B, C, D, 13, 4, 0x289b7ec6);
OP (FH, D, A, B, C, 0, 11, 0xeaa127fa);
OP (FH, C, D, A, B, 3, 16, 0xd4ef3085);
OP (FH, B, C, D, A, 6, 23, 0x04881d05);
OP (FH, A, B, C, D, 9, 4, 0xd9d4d039);
OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
OP (FH, B, C, D, A, 2, 23, 0xc4ac5665);
/* Round 4. */
OP (FI, A, B, C, D, 0, 6, 0xf4292244);
OP (FI, D, A, B, C, 7, 10, 0x432aff97);
OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
OP (FI, B, C, D, A, 5, 21, 0xfc93a039);
OP (FI, A, B, C, D, 12, 6, 0x655b59c3);
OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92);
OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
OP (FI, B, C, D, A, 1, 21, 0x85845dd1);
OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f);
OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
OP (FI, C, D, A, B, 6, 15, 0xa3014314);
OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
OP (FI, A, B, C, D, 4, 6, 0xf7537e82);
OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
OP (FI, B, C, D, A, 9, 21, 0xeb86d391);
/* Put checksum in context given as argument. */
ctx->A += A;
ctx->B += B;
ctx->C += C;
ctx->D += D;
}
/* The routine updates the message-digest context to
* account for the presence of each of the characters inBuf[0..inLen-1]
* in the message whose digest is being computed.
*/
static void
md5_update(MD5_CONTEXT *hd, const unsigned char *inbuf, size_t inlen)
{
if (hd->count == 64) { /* flush the buffer */
transform( hd, hd->buf );
hd->count = 0;
hd->nblocks++;
}
if (!inbuf)
return;
if (hd->count) {
for (; inlen && hd->count < 64; inlen--)
hd->buf[hd->count++] = *inbuf++;
md5_update(hd, NULL, 0);
if (!inlen)
return;
}
while (inlen >= 64) {
transform(hd, inbuf);
hd->count = 0;
hd->nblocks++;
inlen -= 64;
inbuf += 64;
}
for (; inlen && hd->count < 64; inlen--)
hd->buf[hd->count++] = *inbuf++;
}
/* The routine final terminates the message-digest computation and
* ends with the desired message digest in mdContext->digest[0...15].
* The handle is prepared for a new MD5 cycle.
* Returns 16 bytes representing the digest.
*/
static void
do_final(MD5_CONTEXT *hd)
{
u32 t, msb, lsb;
unsigned char *p;
md5_update(hd, NULL, 0); /* flush */
msb = 0;
t = hd->nblocks;
if ((lsb = t << 6) < t) /* multiply by 64 to make a byte count */
msb++;
msb += t >> 26;
t = lsb;
if ((lsb = t + hd->count) < t) /* add the count */
msb++;
t = lsb;
if ((lsb = t << 3) < t) /* multiply by 8 to make a bit count */
msb++;
msb += t >> 29;
if (hd->count < 56) { /* enough room */
hd->buf[hd->count++] = 0x80; /* pad */
while(hd->count < 56)
hd->buf[hd->count++] = 0; /* pad */
} else { /* need one extra block */
hd->buf[hd->count++] = 0x80; /* pad character */
while (hd->count < 64)
hd->buf[hd->count++] = 0;
md5_update(hd, NULL, 0); /* flush */
memset(hd->buf, 0, 56); /* fill next block with zeroes */
}
/* append the 64 bit count */
hd->buf[56] = lsb ;
hd->buf[57] = lsb >> 8;
hd->buf[58] = lsb >> 16;
hd->buf[59] = lsb >> 24;
hd->buf[60] = msb ;
hd->buf[61] = msb >> 8;
hd->buf[62] = msb >> 16;
hd->buf[63] = msb >> 24;
transform(hd, hd->buf);
p = hd->buf;
#ifdef BIG_ENDIAN_HOST
#define X(a) do { *p++ = hd->a ; *p++ = hd->a >> 8; \
*p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
#else /* little endian */
/*#define X(a) do { *(u32*)p = hd->##a ; p += 4; } while(0)*/
/* Unixware's cpp doesn't like the above construct so we do it his way:
* (reported by Allan Clark) */
#define X(a) do { *(u32*)p = (*hd).a ; p += 4; } while(0)
#endif
X(A);
X(B);
X(C);
X(D);
#undef X
hd->finalized = 1;
}
static void
md5_final(unsigned char *digest, MD5_CONTEXT *ctx)
{
if (!ctx->finalized)
do_final(ctx);
memcpy(digest, ctx->buf, 16);
}
/*
* Creates a MD5 digest in hex fomrat (lowercase letters) from the
* string S. hextdigest but be buffer of at lease 33 bytes!
*/
static void
md5_hex_digest(char *hexdigest, const unsigned char *s)
{
int i;
MD5_CONTEXT context;
unsigned char digest[16];
md5_init(&context);
md5_update(&context, s, strlen((gchar *) s));
md5_final(digest, &context);
for (i = 0; i < 16; i++)
sprintf(hexdigest + 2 * i, "%02x", digest[i]);
}
/*
** Function: md5_hmac
** taken from the file rfc2104.txt
** written by Martin Schaaf <mascha@ma-scha.de>
*/
static void
md5_hmac(unsigned char *digest,
const unsigned char* text, int text_len,
const unsigned char* key, int key_len)
{
MD5_CONTEXT context;
unsigned char k_ipad[64]; /* inner padding -
* key XORd with ipad
*/
unsigned char k_opad[64]; /* outer padding -
* key XORd with opad
*/
/* unsigned char tk[16]; */
int i;
/* start out by storing key in pads */
memset(k_ipad, 0, sizeof k_ipad);
memset(k_opad, 0, sizeof k_opad);
if (key_len > 64) {
/* if key is longer than 64 bytes reset it to key=MD5(key) */
MD5_CONTEXT tctx;
md5_init(&tctx);
md5_update(&tctx, key, key_len);
md5_final(k_ipad, &tctx);
md5_final(k_opad, &tctx);
} else {
memcpy(k_ipad, key, key_len);
memcpy(k_opad, key, key_len);
}
/*
* the HMAC_MD5 transform looks like:
*
* MD5(K XOR opad, MD5(K XOR ipad, text))
*
* where K is an n byte key
* ipad is the byte 0x36 repeated 64 times
* opad is the byte 0x5c repeated 64 times
* and text is the data being protected
*/
/* XOR key with ipad and opad values */
for (i = 0; i < 64; i++) {
k_ipad[i] ^= 0x36;
k_opad[i] ^= 0x5c;
}
/*
* perform inner MD5
*/
md5_init(&context); /* init context for 1st
* pass */
md5_update(&context, k_ipad, 64); /* start with inner pad */
md5_update(&context, text, text_len); /* then text of datagram */
md5_final(digest, &context); /* finish up 1st pass */
/*
* perform outer MD5
*/
md5_init(&context); /* init context for 2nd
* pass */
md5_update(&context, k_opad, 64); /* start with outer pad */
md5_update(&context, digest, 16); /* then results of 1st
* hash */
md5_final(digest, &context); /* finish up 2nd pass */
}
static void
md5_hex_hmac(char *hexdigest,
const unsigned char* text, int text_len,
const unsigned char* key, int key_len)
{
unsigned char digest[16];
int i;
md5_hmac(digest, text, text_len, key, key_len);
for (i = 0; i < 16; i++)
sprintf(hexdigest + 2 * i, "%02x", digest[i]);
}
void caldav_md5_hex_digest(char *hexdigest, const unsigned char *s) {
md5_hex_digest(hexdigest, s);
}
void caldav_md5_hex_hmac(char *hexdigest,
const unsigned char* text, int text_len,
const unsigned char* key, int key_len) {
md5_hex_hmac(hexdigest, text, text_len, key, key_len);
}

52
src/.svn/text-base/md5.h.svn-base
Unescape View File

@ -0,0 +1,52 @@
/**
* md5.h - MD5 Message-Digest Algorithm
* Copyright (C) 1995, 1996, 1998, 1999 Free Software Foundation, Inc.
*
* according to the definition of MD5 in RFC 1321 from April 1992.
* NOTE: This is *not* the same file as the one from glibc
*
* 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, 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 <http://www.gnu.org/licenses/>.
*/
#ifndef _MD5_HDR_
#define _MD5_HDR_
#include <glib.h>
/**
* @typedef u32
* Kept this typedef for compatibility reasons
*/
#ifndef HAVE_U32_TYPEDEF
#undef u32
typedef guint32 u32;
#define HAVE_U32_TYPEDEF
#endif
typedef struct { /* Hmm, should be private */
u32 A,B,C,D;
u32 nblocks;
unsigned char buf[64];
int count;
int finalized;
} MD5_CONTEXT;
void caldav_md5_hex_digest(char *hexdigest, const unsigned char *s);
void caldav_md5_hex_hmac(char *hexdigest,
const unsigned char* text, int text_len,
const unsigned char* key, int key_len);
#endif /* _MD5_HDR_ */

296
src/.svn/text-base/modify-caldav-object.c.svn-base
Unescape View File

@ -0,0 +1,296 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "modify-caldav-object.h"
#include "lock-caldav-object.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the first part of the calendar query.
* The actual UID to use for the query is added at runtime.
*/
static char* search_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VEVENT\">"
" <C:prop-filter name=\"UID\">";
/**
* A static literal string containing the last part of the calendar query
*/
static char* search_tail =
"</C:prop-filter>"
" </C:comp-filter>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>";
/**
* Function for modifying an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_modify(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* search;
gchar* uid;
gboolean result = FALSE;
gboolean LOCKSUPPORT = FALSE;
gchar* lock_token = NULL;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* file = g_strdup(settings->file);
if ((uid = get_response_header("uid", file, FALSE)) == NULL) {
g_free(file);
error->code = 1;
error->str = g_strdup("Error: Missing required UID for object");
return TRUE;
}
g_free(file);
/*
* collation is not supported by ICalendar.
* <C:text-match collation=\"i;ascii-casemap\">%s</C:text-match>
*/
search = g_strdup_printf(
"%s\r\n<C:text-match>%s</C:text-match>\r\n%s",
search_head, uid, search_tail);
g_free(uid);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, search);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(search));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
curl_slist_free_all(http_header);
http_header = NULL;
g_free(search);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
else {
/* enable uploading */
gchar* url = NULL;
gchar* etag = NULL;
url = get_url(chunk.memory);
if (url) {
etag = get_etag(chunk.memory);
if (etag) {
gchar* host = get_host(settings->url);
if (host) {
file = g_strdup(url);
g_free(url);
url = g_strdup_printf("%s%s", host, file);
g_free(file);
g_free(host);
}
else {
g_free(etag);
g_free(url);
url = NULL;
}
}
else {
g_free(url);
url = NULL;
}
if (url) {
int lock = 0;
caldav_error lock_error;
file = g_strdup(etag);
g_free(etag);
etag = g_strdup_printf("If-Match: %s", file);
g_free(file);
http_header = curl_slist_append(http_header, etag);
g_free(etag);
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(
http_header, "Transfer-Encoding:");
if (settings->use_locking)
LOCKSUPPORT = caldav_lock_support(settings, &lock_error);
else
LOCKSUPPORT = FALSE;
if (LOCKSUPPORT) {
lock_token = caldav_lock_object(url, settings, &lock_error);
if (lock_token) {
http_header = curl_slist_append(
http_header, g_strdup_printf(
"If: (%s)", lock_token));
}
/*
* If error code is 423 (Resource is LOCKED) bail out
*/
else if (lock_error.code == 423) {
lock = -1;
}
/*
* If error code is 501 (Not implemented) we continue
* hoping for the best.
*/
else if (lock_error.code == 501) {
lock_token = g_strdup("");
}
else {
lock = -1;
}
}
if (! LOCKSUPPORT || (LOCKSUPPORT && lock_token && lock_error.code != 423)) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_URL, rebuild_url(settings, url));
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, settings->file);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE,
strlen(settings->file));
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
res = curl_easy_perform(curl);
if (LOCKSUPPORT && lock_token) {
caldav_unlock_object(
lock_token, url, settings, &lock_error);
}
}
g_free(url);
g_free(lock_token);
if (res != 0 || lock < 0) {
/* Is this a lock_error don't change error*/
if (lock == 0 || lock_error.code == 423) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
error->code = lock_error.code;
error->str = g_strdup(lock_error.str);
}
result = TRUE;
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(
curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
}
curl_slist_free_all(http_header);
}
else {
error->code = code;
if (chunk.memory)
error->str = g_strdup(chunk.memory);
else
error->str = g_strdup("No object found");
result = TRUE;
}
}
else {
/*
* No object found on server. Posible synchronization
* problem or a server side race condition
*/
error->code = 409;
error->str = g_strdup("No object found");
result = TRUE;
}
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}

34
src/.svn/text-base/modify-caldav-object.h.svn-base
Unescape View File

@ -0,0 +1,34 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __MODIFY_CALDAV_OBJECT_H__
#define __MODIFY_CALDAV_OBJECT_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function for modifying an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_modify(caldav_settings* settings, caldav_error* error);
#endif

135
src/.svn/text-base/options-caldav-server.c.svn-base
Unescape View File

@ -0,0 +1,135 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "options-caldav-server.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* Function for getting supported options from a server.
* @param curl A pointer to an initialized CURL instance
* @param settings struct containing the URL to the server. If authentication
* is required prior to making the call the credentials must be available
* via CURLOPT_USERPWD before calling.
* @param result A pointer to a struct _response. If test is true
* this variable can be NULL. Caller is responsible for freeing associated
* memory.
* @param error A pointer to caldav_error. @see caldav_error
* @param test if this is true response will be whether the server
* represented by the URL is a CalDAV collection or not.
* @return FALSE in case of error, TRUE otherwise.
*/
gboolean caldav_getoptions(CURL* curl, caldav_settings* settings, response* result,
caldav_error* error, gboolean test) {
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct MemoryStruct chunk;
struct MemoryStruct headers;
gboolean enabled = FALSE;
if (! curl)
return FALSE;
if (!error) {
error = (caldav_error *) malloc(sizeof(struct _caldav_error));
memset(error, '\0', sizeof(struct _caldav_error));
}
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res == 0) {
gchar* head;
head = get_response_header("DAV", headers.memory, TRUE);
if (head && strstr(head, "calendar-access") != NULL) {
enabled = TRUE;
if (! test) {
result->msg = g_strdup(
get_response_header("Allow", headers.memory, FALSE));
}
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code == 200) {
error->code = -1;
error->str = g_strdup("URL is not a CalDAV resource");
}
else {
error->code = -1 * code;
error->str = g_strdup(headers.memory);
}
}
g_free(head);
}
else if (
(res == CURLE_SSL_CONNECT_ERROR ||
CURLE_PEER_FAILED_VERIFICATION ||
CURLE_SSL_ENGINE_NOTFOUND ||
CURLE_SSL_ENGINE_SETFAILED ||
CURLE_SSL_CERTPROBLEM ||
CURLE_SSL_CIPHER ||
CURLE_SSL_CACERT ||
CURLE_SSL_CACERT_BADFILE ||
CURLE_SSL_CRL_BADFILE ||
CURLE_SSL_ISSUER_ERROR) && settings->usehttps) {
error->code = -2;
error->str = g_strdup(error_buf);
}
else if (res == CURLE_COULDNT_RESOLVE_HOST) {
error->code = -3;
error->str = g_strdup("Could not resolve host");
}
else if (res == CURLE_COULDNT_CONNECT) {
error->code = -4;
error->str = g_strdup("Unable to connect");
}
else {
error->code = -1;
error->str = g_strdup("URL is not a CalDAV resource");
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
return enabled;
}

43
src/.svn/text-base/options-caldav-server.h.svn-base
Unescape View File

@ -0,0 +1,43 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __OPTIONS_CALDAV_SERVER_H__
#define __OPTIONS_CALDAV_SERVER_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function for getting supported options from a server.
* @param curl A pointer to an initialized CURL instance
* @param settings struct containing the URL to the server. If authentication
* is required prior to making the call the credentials must be available
* via CURLOPT_USERPWD before calling.
* @param result A pointer to a struct _response. If test is true
* this variable can be NULL. Caller is responsible for freeing associated
* memory.
* @param error A pointer to caldav_error. @see caldav_error
* @param test if this is true response will be whether the server
* represented by the URL is a CalDAV collection or not.
* @return FALSE in case of error, TRUE otherwise.
*/
gboolean caldav_getoptions(CURL* curl, caldav_settings* settings, response* result,
caldav_error* error, gboolean test);
#endif

53
src/Makefile.am
Unescape View File

@ -0,0 +1,53 @@
AUTOMAKE_OPTIONS = gnu
INCLUDES = @CURL_CFLAGS@ @GLIB_CFLAGS@ \
-I$(top_srcdir) -I$(top_builddir)
if STATIC_LINK
noinst_LTLIBRARIES = libcaldav.la
endif
if DYNAMIC_LINK
lib_LTLIBRARIES = libcaldav.la
endif
libcaldav_la_LDFLAGS = -version-info @LIBVERSION@
libcaldav_la_SOURCES = \
caldav.h \
caldav.c \
add-caldav-object.c \
add-caldav-object.h \
delete-caldav-object.c \
delete-caldav-object.h \
modify-caldav-object.c \
modify-caldav-object.h \
get-caldav-report.c \
get-caldav-report.h \
get-display-name.c \
get-display-name.h \
caldav-utils.c \
caldav-utils.h \
md5.c \
md5.h \
options-caldav-server.c \
options-caldav-server.h \
lock-caldav-object.c \
lock-caldav-object.h \
get-freebusy-report.c \
get-freebusy-report.h
libcaldav_includedir=$(includedir)/libcaldav-@VERSION@
libcaldav_include_HEADERS = caldav.h
noinst_HEADERS = \
add-caldav-object.h \
delete-caldav-object.h \
modify-caldav-object.h \
get-caldav-report.h \
caldav-utils.h
libcaldav_la_LIBADD = \
@CURL_LIBS@ \
@GLIB_LIBS@

649
src/Makefile.in
Unescape View File

@ -0,0 +1,649 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = src
DIST_COMMON = $(libcaldav_include_HEADERS) $(noinst_HEADERS) \
$(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__installdirs = "$(DESTDIR)$(libdir)" \
"$(DESTDIR)$(libcaldav_includedir)"
LTLIBRARIES = $(lib_LTLIBRARIES) $(noinst_LTLIBRARIES)
libcaldav_la_DEPENDENCIES =
am_libcaldav_la_OBJECTS = caldav.lo add-caldav-object.lo \
delete-caldav-object.lo modify-caldav-object.lo \
get-caldav-report.lo get-display-name.lo caldav-utils.lo \
md5.lo options-caldav-server.lo lock-caldav-object.lo \
get-freebusy-report.lo
libcaldav_la_OBJECTS = $(am_libcaldav_la_OBJECTS)
libcaldav_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(libcaldav_la_LDFLAGS) $(LDFLAGS) -o $@
@DYNAMIC_LINK_TRUE@am_libcaldav_la_rpath = -rpath $(libdir)
@STATIC_LINK_TRUE@am_libcaldav_la_rpath =
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(libcaldav_la_SOURCES)
DIST_SOURCES = $(libcaldav_la_SOURCES)
HEADERS = $(libcaldav_include_HEADERS) $(noinst_HEADERS)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
INCLUDES = @CURL_CFLAGS@ @GLIB_CFLAGS@ \
-I$(top_srcdir) -I$(top_builddir)
@STATIC_LINK_TRUE@noinst_LTLIBRARIES = libcaldav.la
@DYNAMIC_LINK_TRUE@lib_LTLIBRARIES = libcaldav.la
libcaldav_la_LDFLAGS = -version-info @LIBVERSION@
libcaldav_la_SOURCES = \
caldav.h \
caldav.c \
add-caldav-object.c \
add-caldav-object.h \
delete-caldav-object.c \
delete-caldav-object.h \
modify-caldav-object.c \
modify-caldav-object.h \
get-caldav-report.c \
get-caldav-report.h \
get-display-name.c \
get-display-name.h \
caldav-utils.c \
caldav-utils.h \
md5.c \
md5.h \
options-caldav-server.c \
options-caldav-server.h \
lock-caldav-object.c \
lock-caldav-object.h \
get-freebusy-report.c \
get-freebusy-report.h
libcaldav_includedir = $(includedir)/libcaldav-@VERSION@
libcaldav_include_HEADERS = caldav.h
noinst_HEADERS = \
add-caldav-object.h \
delete-caldav-object.h \
modify-caldav-object.h \
get-caldav-report.h \
caldav-utils.h
libcaldav_la_LIBADD = \
@CURL_LIBS@ \
@GLIB_LIBS@
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu src/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
install-libLTLIBRARIES: $(lib_LTLIBRARIES)
@$(NORMAL_INSTALL)
test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"
@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
list2=; for p in $$list; do \
if test -f $$p; then \
list2="$$list2 $$p"; \
else :; fi; \
done; \
test -z "$$list2" || { \
echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
$(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
}
uninstall-libLTLIBRARIES:
@$(NORMAL_UNINSTALL)
@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
for p in $$list; do \
$(am__strip_dir) \
echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
$(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
done
clean-libLTLIBRARIES:
-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
test "$$dir" != "$$p" || dir=.; \
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
clean-noinstLTLIBRARIES:
-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
test "$$dir" != "$$p" || dir=.; \
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
libcaldav.la: $(libcaldav_la_OBJECTS) $(libcaldav_la_DEPENDENCIES)
$(libcaldav_la_LINK) $(am_libcaldav_la_rpath) $(libcaldav_la_OBJECTS) $(libcaldav_la_LIBADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/add-caldav-object.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/caldav-utils.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/caldav.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/delete-caldav-object.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get-caldav-report.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get-display-name.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/get-freebusy-report.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/lock-caldav-object.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/md5.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/modify-caldav-object.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/options-caldav-server.Plo@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
install-libcaldav_includeHEADERS: $(libcaldav_include_HEADERS)
@$(NORMAL_INSTALL)
test -z "$(libcaldav_includedir)" || $(MKDIR_P) "$(DESTDIR)$(libcaldav_includedir)"
@list='$(libcaldav_include_HEADERS)'; test -n "$(libcaldav_includedir)" || list=; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
echo "$$d$$p"; \
done | $(am__base_list) | \
while read files; do \
echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(libcaldav_includedir)'"; \
$(INSTALL_HEADER) $$files "$(DESTDIR)$(libcaldav_includedir)" || exit $$?; \
done
uninstall-libcaldav_includeHEADERS:
@$(NORMAL_UNINSTALL)
@list='$(libcaldav_include_HEADERS)'; test -n "$(libcaldav_includedir)" || list=; \
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
test -n "$$files" || exit 0; \
echo " ( cd '$(DESTDIR)$(libcaldav_includedir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(libcaldav_includedir)" && rm -f $$files
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(LTLIBRARIES) $(HEADERS)
installdirs:
for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(libcaldav_includedir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
clean-noinstLTLIBRARIES mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am: install-libcaldav_includeHEADERS
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-libLTLIBRARIES
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-libLTLIBRARIES \
uninstall-libcaldav_includeHEADERS
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
clean-libLTLIBRARIES clean-libtool clean-noinstLTLIBRARIES \
ctags distclean distclean-compile distclean-generic \
distclean-libtool distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-libLTLIBRARIES \
install-libcaldav_includeHEADERS install-man install-pdf \
install-pdf-am install-ps install-ps-am install-strip \
installcheck installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
tags uninstall uninstall-am uninstall-libLTLIBRARIES \
uninstall-libcaldav_includeHEADERS
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

132
src/add-caldav-object.c
Unescape View File

@ -0,0 +1,132 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "add-caldav-object.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* Function for adding a new event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_add(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
gchar* url;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "If-None-Match: *");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* tmp = random_file_name(settings->file);
gchar* s = rebuild_url(settings, NULL);
if (g_str_has_suffix(s, "/")) {
url = g_strdup_printf("%slibcaldav-%s.ics", s, tmp);
}
else {
url = g_strdup_printf("%s/libcaldav-%s.ics", s, tmp);
}
g_free(s);
g_free(tmp);
curl_easy_setopt(curl, CURLOPT_URL, url);
tmp = g_strdup(settings->file);
g_free(settings->file);
settings->file = verify_uid(tmp);
g_free(tmp);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, settings->file);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(settings->file));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 201) {
error->str = g_strdup(chunk.memory);
error->code = code;
result = TRUE;
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}

35
src/add-caldav-object.h
Unescape View File

@ -0,0 +1,35 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __ADD_CALDAV_OBJECT_H__
#define __ADD_CALDAV_OBJECT_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function for adding a new event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_add(caldav_settings* settings, caldav_error* error);
#endif

729
src/caldav-utils.c
Unescape View File

@ -0,0 +1,729 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "caldav-utils.h"
#include "md5.h"
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <curl/curl.h>
#include <ctype.h>
/**
* This function is burrowed from the libcurl documentation
* @param text
* @param stream
* @param ptr
* @param size
* @param nohex
*/
void dump(const char* text, FILE* stream, char* ptr, size_t size, char nohex) {
size_t i;
size_t c;
unsigned int width=0x10;
if(nohex)
/* without the hex output, we can fit more on screen */
width = 0x40;
fprintf(stream, "%s, %zd bytes (0x%zx)\n", text, size, size);
for(i=0; i<size; i+= width) {
fprintf(stream, "%04zx: ", i);
if(!nohex) {
/* hex not disabled, show it */
for(c = 0; c < width; c++) {
if(i+c < size)
fprintf(stream, "%02x ", ptr[i+c]);
else
fputs(" ", stream);
}
}
for(c = 0; (c < width) && (i+c < size); c++) {
/* check for 0D0A; if found, skip past and start a new line of output */
if (nohex && (i+c+1 < size) && ptr[i+c]==0x0D && ptr[i+c+1]==0x0A) {
i+=(c+2-width);
break;
}
fprintf(stream, "%c",(ptr[i+c]>=0x20) && (ptr[i+c]<0x80)?ptr[i+c]:'.');
/* check again for 0D0A, to avoid an extra \n if it's at width */
if (nohex && (i+c+2 < size) && ptr[i+c+1]==0x0D && ptr[i+c+2]==0x0A) {
i+=(c+3-width);
break;
}
}
fputc('\n', stream); /* newline */
}
fflush(stream);
}
/**
* This function is burrowed from the libcurl documentation
* @param handle
* @param type
* @param data
* @param size
* @param userp
* @return
*/
int my_trace(CURL* handle, curl_infotype type, char* data, size_t size, void* userp) {
struct config_data* config = (struct config_data *)userp;
const char* text;
(void)handle; /* prevent compiler warning */
switch (type) {
case CURLINFO_TEXT:
fprintf(stderr, "== Info: %s", data);
default: /* in case a new one is introduced to shock us */
return 0;
case CURLINFO_HEADER_OUT:
text = "=> Send header";
break;
case CURLINFO_DATA_OUT:
text = "=> Send data";
break;
case CURLINFO_SSL_DATA_OUT:
text = "=> Send SSL data";
break;
case CURLINFO_HEADER_IN:
text = "<= Recv header";
break;
case CURLINFO_DATA_IN:
text = "<= Recv data";
break;
case CURLINFO_SSL_DATA_IN:
text = "<= Recv SSL data";
break;
}
dump(text, stderr, data, size, config->trace_ascii);
return 0;
}
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @return void* to memory region
*/
static void* myrealloc(void* ptr, size_t size) {
/* There might be a realloc() out there that doesn't like reallocing
* NULL pointers, so we take care of it here
* */
if(ptr)
return realloc(ptr, size);
else
return malloc(size);
}
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @param nmemb
* @param data
* @return number of written bytes
*/
size_t WriteMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data) {
size_t realsize = size * nmemb;
struct MemoryStruct* mem = (struct MemoryStruct *)data;
mem->memory = (char *)myrealloc(mem->memory, mem->size + realsize + 1);
if (mem->memory) {
memcpy(&(mem->memory[mem->size]), ptr, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
}
return realsize;
}
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @param nmemb
* @param data
* @return number of written bytes
*/
size_t WriteHeaderCallback(void* ptr, size_t size, size_t nmemb, void* data) {
size_t realsize = size * nmemb;
struct MemoryStruct* mem = (struct MemoryStruct *)data;
mem->memory = (char *)myrealloc(mem->memory, mem->size + realsize + 1);
if (mem->memory) {
memcpy(&(mem->memory[mem->size]), ptr, realsize);
mem->size += realsize;
mem->memory[mem->size] = 0;
}
return realsize;
}
/*
size_t ReadMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data){
struct MemoryStruct* mem = (struct MemoryStruct *)data;
memcpy(ptr, mem->memory, mem->size);
return mem->size;
}
*/
/**
* Initialize caldav settings structure.
* @param settings @see caldav_settings
*/
void init_caldav_settings(caldav_settings* settings) {
settings->username = NULL;
settings->password = NULL;
settings->url = NULL;
settings->file = NULL;
settings->usehttps = FALSE;
settings->custom_cacert = NULL;
settings->verify_ssl_certificate = TRUE;
settings->debug = FALSE;
settings->trace_ascii = TRUE;
settings->ACTION = UNKNOWN;
settings->start = 0;
settings->end = 0;
}
/**
* Free memory assigned to caldav settings structure.
* @param settings @see caldav_settings
*/
void free_caldav_settings(caldav_settings* settings) {
if (settings->username) {
g_free(settings->username);
settings->username = NULL;
}
if (settings->password) {
g_free(settings->password);
settings->password = NULL;
}
if (settings->url) {
g_free(settings->url);
settings->url = NULL;
}
if (settings->file) {
g_free(settings->file);
settings->file = NULL;
}
if (settings->custom_cacert) {
g_free(settings->custom_cacert);
settings->custom_cacert = NULL;
}
settings->verify_ssl_certificate = TRUE;
settings->usehttps = FALSE;
settings->debug = FALSE;
settings->trace_ascii = TRUE;
settings->ACTION = UNKNOWN;
settings->start = 0;
settings->end = 0;
}
static gchar* place_after_hostname(const gchar* start, const gchar* stop) {
gchar* newpos = NULL;
gchar* pos = (gchar *) stop;
gboolean digit = TRUE;
if (pos && stop && strcmp(start, pos) != 0) {
while (*pos != ':' && strcmp(start, pos) != 0)
--pos;
if (pos > start) {
gchar* tmp = (gchar *) pos + 1;
/* is pos++ a port number */
while (*tmp != '/' && digit) {
if (isdigit(*tmp) != 0) {
digit = TRUE;
tmp++;
}
else
digit = FALSE;
}
if (digit) {
/* pos was a port number */
while (*pos != '@' && strcmp(start, pos) != 0)
--pos;
if (strcmp(start, pos) != 0)
newpos = pos;
}
else {
while (*pos != '@' && pos != stop)
pos++;
if (pos != stop)
newpos = pos;
}
}
else {
/* is a username present */
gchar* tmp = NULL;
while (*pos != '/' && pos != stop) {
if (*pos == '@')
tmp = pos;
pos++;
}
if (tmp && pos != stop)
newpos = tmp;
}
}
return newpos;
}
/**
* Parse URL
* @param settings @see caldav_settings
* @param url String containing URL to collection
*/
void parse_url(caldav_settings* settings, const char* url) {
char* start;
char* pos;
char* end;
char* login;
login = pos = end = start = NULL;
if (!url)
return;
if ((pos = strstr(url, "//")) != NULL) {
/* Does the URL use https ?*/
if (!g_ascii_strncasecmp(url,"https",5) && settings->usehttps == FALSE) {
settings->usehttps=TRUE;
}
start = g_strdup(&(*(pos + 2)));
if ((pos = place_after_hostname(start, strrchr(start, '\0') - 1)) != NULL) {
/* username and/or password present */
login = g_strndup(start, pos - start);
end = pos;
if ((pos = strrchr(login, ':')) != NULL) {
/* both username and password is present */
settings->username = g_strndup(login, pos - login);
settings->password = g_strdup(++pos);
}
else {
/* only username present */
settings->username = g_strdup(login);
settings->password = NULL;
}
g_free(login);
settings->url = g_strdup(++end);
}
else {
/* no username or password present */
settings->url = g_strdup(start);
settings->username = NULL;
settings->password = NULL;
}
g_free(start);
}
}
/**
* Find a specific HTTP header from last request
* @param header HTTP header to search for
* @param headers String of HTTP headers from last request
* @param lowcase Should string be returned in all lower case.
* @return The header found or NULL
*/
#define MAX_TOKENS 2
gchar* get_response_header(
const char* header, gchar* headers, gboolean lowcase) {
gchar* line;
gchar* head = NULL;
gchar* oldhead = NULL;
gchar** buf;
gchar* header_list;
gchar* saveptr;
header_list = g_strdup(headers);
line = strtok_r(header_list, "\r\n", &saveptr);
if (line != NULL) {
do {
buf = g_strsplit(line, ":", MAX_TOKENS);
if (buf[1] != NULL) {
if (g_ascii_strcasecmp(buf[0], header) == 0) {
if (head) {
if (strcmp(head, buf[1]) != 0) {
oldhead = head;
head = g_strconcat(head, ", ", buf[1], NULL);
g_free(oldhead);
}
}
else
head = g_strdup(buf[1]);
if (head)
g_strstrip(head);
}
}
g_strfreev(buf);
} while ((line = strtok_r(NULL, "\r\n", &saveptr)) != NULL);
}
g_free(header_list);
if (head)
return (lowcase) ? g_ascii_strdown(head, -1) : head;
else
return NULL;
}
static const char* VCAL_HEAD =
"BEGIN:VCALENDAR\r\n"
"PRODID:-//CalDAV Calendar//NONSGML libcaldav//EN\r\n"
"VERSION:2.0\r\n";
static const char* VCAL_FOOT = "END:VCALENDAR";
/**
* Parse response from CalDAV server. Internal function.
* @param report Response from server
* @param element XML element to find
* @param type VCalendar element to find
* @param wrap Is this the final parsing or just a part
* @param recursive Stop after first match or not
* @return the parsed result
*/
static gchar* parse_caldav_report_wrap(
char* report, const char* element, const char* type,
gboolean wrap, gboolean recursive) {
char* pos;
char* start;
char* object;
char* tmp_report;
char* tmp;
gchar* response;
gchar* begin_type;
gchar* end_type;
gboolean keep_going = TRUE;
begin_type = g_strdup_printf("BEGIN:%s", type);
end_type = g_strdup_printf("END:%s", type);
pos = start = object = response = NULL;
tmp_report = g_strdup(report);
while ((pos = strstr(tmp_report, element)) != NULL && keep_going) {
pos = strchr(pos, '>');
if (!pos) {
break;
}
pos = &(*(pos + 1));
pos = strstr(pos, begin_type);
if (!pos) {
break;
}
object = &(*(pos + strlen(begin_type)));
object = g_strchug(object);
start = g_strdup(object);
if ((pos = strstr(start, end_type)) == NULL) {
g_free(start);
break;
}
char end_not_found = 1;
while (end_not_found == 1) {
if (strstr(pos+1, end_type) < strstr(pos+1, element)) {
if (strstr(pos+1, end_type) != NULL) {
pos = strstr(pos+1, end_type);
}
else {
end_not_found = 0;
}
}
else {
end_not_found = 0;
}
}
object = g_strndup(start, strlen(start) - strlen(pos));
if (response) {
tmp = g_strdup(response);
g_free(response);
response = g_strdup_printf("%s%s\r\n%s%s\r\n",
tmp, begin_type, object, end_type);
g_free(tmp);
}
else {
if (wrap)
response = g_strdup_printf("%s%s\r\n%s%s\r\n",
VCAL_HEAD, begin_type, object, end_type);
else
response = g_strdup_printf("%s\r\n%s%s\r\n",
begin_type, object, end_type);
}
if (recursive) {
pos = strchr(pos, '>');
g_free(tmp_report);
tmp_report = g_strdup(&(*(pos + 1)));
}
else {
keep_going = FALSE;
}
g_free(start);
g_free(object);
}
g_free(tmp_report);
g_free(begin_type);
g_free(end_type);
if (wrap)
if (response) {
object = g_strdup(response);
g_free(response);
response = g_strdup_printf("%s%s", object, VCAL_FOOT);
g_free(object);
}
return response;
}
/**
* Parse response from CalDAV server
* @param report Response from server
* @param element XML element to find
* @param type VCalendar element to find
* @return the parsed result
*/
gchar* parse_caldav_report(char* report, const char* element, const char* type) {
gchar* response = NULL;
gchar* timezone = NULL;
gchar* temp = NULL;
if (!report || !element || !type)
return NULL;
/* test for VTIMEZONE.
* Only the first found will be used and this will then
* be the time zone for the entire report
*/
timezone = parse_caldav_report_wrap(
report, element, "VTIMEZONE", FALSE, FALSE);
if (timezone) {
response = g_strdup_printf("%s%s", VCAL_HEAD, timezone);
g_free(timezone);
temp = parse_caldav_report_wrap(report, element, type, FALSE, TRUE);
if (temp) {
gchar* tmp = g_strdup(response);
g_free(response);
response = g_strdup_printf("%s%s%s", tmp, temp, VCAL_FOOT);
g_free(tmp);
g_free(temp);
}
else {
g_free(response);
return NULL;
}
}
else
response = parse_caldav_report_wrap(report, element, type, TRUE, TRUE);
return response;
}
/**
* Convert a time_t variable to CalDAV DateTime
* @param time a specific date and time
* @return the CalDAV DateTime
*/
gchar* get_caldav_datetime(time_t* time) {
struct tm *current;
gchar* datetime;
current = localtime(time);
datetime = g_strdup_printf("%d%.2d%.2dT%.2d%.2d%.2dZ",
current->tm_year + 1900, current->tm_mon + 1, current->tm_mday,
current->tm_hour, current->tm_min, current->tm_sec);
return datetime;
}
/**
* Create a random text string, using MD5. @see caldav_md5_hex_digest()
* @param text some text to randomize
* @return MD5 hash of text
*/
gchar* random_file_name(gchar* text) {
unsigned char* name;
gchar md5sum[33];
name = (unsigned char *) g_strdup(text);
caldav_md5_hex_digest(md5sum, name);
g_free(name);
return g_strdup(md5sum);
}
/**
* Does the event contain a UID element or not. If not add it.
* @param object A specific event
* @return event, eventually added UID
*/
gchar* verify_uid(gchar* object) {
gchar* uid;
gchar* newobj;
gchar* pos;
newobj = g_strdup(object);
uid = get_response_header("uid", object, TRUE);
if (!uid) {
object = g_strdup(newobj);
g_free(newobj);
pos = strstr(object, "END:VEVENT");
newobj = g_strndup(object, strlen(object) - strlen(pos));
newobj = g_strchomp(newobj);
uid = random_file_name(object);
gchar*tmp = g_strdup(newobj);
g_free(newobj);
newobj = g_strdup_printf("%s\r\nUID:libcaldav-%s@tempuri.org\r\n%s",
tmp, uid, pos);
g_free(uid);
g_free(tmp);
g_free(object);
}
else
g_free(uid);
/*uid = g_strdup(newobj);
g_free(newobj);*/
g_strchomp(newobj);
/*g_free(uid);*/
return newobj;
}
/**
* Fetch a URL from a XML element
* @param text String
* @return URL
*/
#define ELEM_HREF "href>"
gchar* get_url(gchar* text) {
gchar* pos;
gchar* url = NULL;
if ((pos = strstr(text, ELEM_HREF)) == NULL)
return url;
pos = &(*(pos + strlen(ELEM_HREF)));
url = g_strndup(pos, strlen(pos) - strlen(strchr(pos, '<')));
return url;
}
/**
* Fetch any element from XML
* @param text String
* @param tag The element to look for
* @return element
*/
gchar* get_tag(const gchar* tag, gchar* text) {
gchar *pos;
gchar* res = NULL;
gchar* the_tag = NULL;
/*printf("%s\n", text);*/
the_tag = g_strdup_printf("<%s>", tag);
if ((pos = strstr(text, the_tag)) == NULL) {
g_free(the_tag);
return res;
}
pos = &(*(pos + strlen(the_tag)));
res = g_strndup(pos, strlen(pos) - strlen(strchr(pos, '<')));
g_free(the_tag);
return res;
}
/**
* Fetch the etag element from XML
* @param text String
* @return etag
*/
#define ELEM_ETAG "getetag"
gchar* get_etag(gchar* text) {
gchar* etag = NULL;
etag = get_tag(ELEM_ETAG, text);
/* Maybe namespace prefixed */
if (!etag) {
etag = get_tag("D:getetag", text);
}
return etag;
}
/**
* Fetch host from URL
* @param url URL
* @return host
*/
gchar* get_host(gchar* url) {
gchar** buf;
gchar* result = NULL;
buf = g_strsplit(url, "/", 2);
if (buf[0]) {
result = g_strdup(buf[0]);
}
g_strfreev(buf);
return result;
}
/**
* rebuild a raw URL with https if needed from the settings
* @param settings caldav_settings
* @param uri URI to use instead of base
* @return URL
*/
gchar* rebuild_url(caldav_settings* settings, gchar* uri){
gchar* url = NULL;
gchar* mystr = NULL;
if (settings->usehttps) {
mystr = "https://";
} else {
mystr = "http://";
}
if (uri)
url = g_strdup_printf("%s%s", mystr, uri);
else
url = g_strdup_printf("%s%s", mystr,settings->url);
return url;
}
/**
* Prepare a curl connection
* @param settings caldav_settings
* @return CURL
*/
CURL* get_curl(caldav_settings* setting) {
CURL* curl;
gchar* userpwd = NULL;
gchar* url = NULL;
curl = curl_easy_init();
if (curl) {
if (setting->username) {
if (setting->password)
userpwd = g_strdup_printf("%s:%s",
setting->username, setting->password);
else
userpwd = g_strdup_printf("%s", setting->username);
curl_easy_setopt(curl, CURLOPT_USERPWD, userpwd);
g_free(userpwd);
}
if (setting->verify_ssl_certificate)
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2);
else {
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
}
if (setting->custom_cacert)
curl_easy_setopt(curl, CURLOPT_CAINFO, setting->custom_cacert);
curl_easy_setopt(curl, CURLOPT_USERAGENT, __CALDAV_USERAGENT);
url = rebuild_url(setting, NULL);
curl_easy_setopt(curl, CURLOPT_URL, url);
g_free(url);
}
return (curl) ? curl : NULL;
}

221
src/caldav-utils.h
Unescape View File

@ -0,0 +1,221 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __CALDAV_UTILS_H__
#define __CALDAV_UTILS_H__
#include <glib.h>
#include <stdlib.h>
#include <curl/curl.h>
#include "caldav.h"
/**
* @typedef struct _CALDAV_SETTINGS caldav_settings
* A pointer to a struct _CALDAV_SETTINGS
*/
typedef struct _CALDAV_SETTINGS caldav_settings;
/**
* @struct _CALDAV_SETTINGS
* A struct used to exchange all user input between various parts
* of the library
*/
struct _CALDAV_SETTINGS {
gchar* username;
gchar* password;
gchar* url;
gchar* file;
gboolean usehttps;
gboolean verify_ssl_certificate;
gchar* custom_cacert;
gboolean debug;
gboolean use_locking;
char trace_ascii;
CALDAV_ACTION ACTION;
time_t start;
time_t end;
};
/**
* @typedef struct MemoryStruct memory_ptr
* A pointer to a struct MemoryStruct
*/
typedef struct MemoryStruct memory_ptr;
/**
* @struct MemoryStruct
* Used to hold messages between the CalDAV server and the library
*/
struct MemoryStruct {
char *memory;
size_t size;
};
/** @struct config_data
* Used to exchange user options to the library
*/
struct config_data {
char trace_ascii;
};
/**
* This function is burrowed from the libcurl documentation
* @param text
* @param stream
* @param ptr
* @param size
* @param nohex
*/
void dump(const char* text, FILE* stream, char* ptr, size_t size, char nohex);
/**
* This function is burrowed from the libcurl documentation
* @param handle
* @param type
* @param data
* @param size
* @param userp
* @return
*/
int my_trace(CURL* handle, curl_infotype type, char* data, size_t size, void* userp);
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @return void* to memory region
*/
size_t WriteMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data);
/**
* This function is burrowed from the libcurl documentation
* @param ptr
* @param size
* @param nmemb
* @param data
* @return number of written bytes
*/
size_t WriteHeaderCallback(void* ptr, size_t size, size_t nmemb, void* data);
/*size_t ReadMemoryCallback(void* ptr, size_t size, size_t nmemb, void* data);*/
/**
* Initialize caldav settings structure.
* @param settings @see caldav_settings
*/
void init_caldav_settings(caldav_settings* settings);
/**
* Free momory assigned to caldav settings structure.
* @param settings @see caldav_settings
*/
void free_caldav_settings(caldav_settings* settings);
/**
* Parse URL
* @param settings @see caldav_settings
* @param url String containing URL to collection
*/
void parse_url(caldav_settings* settings, const char* url);
/**
* Find a specific HTTP header from last request
* @param header HTTP header to search for
* @param headers String of HTTP headers from last request
* @param lowcase Should string be returned in all lower case.
* @return The header found or NULL
*/
gchar* get_response_header(
const char* header, gchar* headers, gboolean lowcase);
/**
* Parse response from CalDAV server
* @param report Response from server
* @param element XML element to find
* @param type VCalendar element to find
* @return the parsed result
*/
gchar* parse_caldav_report(char* report, const char* element, const char* type);
/**
* Convert a time_t variable to CalDAV DateTime
* @param time a specific date and time
* @return the CalDAV DateTime
*/
gchar* get_caldav_datetime(time_t* time);
/**
* Create a random text string, using MD5. @see caldav_md5_hex_digest()
* @param text some text to randomize
* @return MD5 hash of text
*/
gchar* random_file_name(gchar* text);
/**
* Does the event contain a UID element or not. If not add it.
* @param object A specific event
* @return event, eventually added UID
*/
gchar* verify_uid(gchar* object);
/**
* Fetch a URL from a XML element
* @param text String
* @return URL
*/
gchar* get_url(gchar* text);
/**
* Fetch host from URL
* @param url URL
* @return host
*/
gchar* get_host(gchar* url);
/**
* Fetch the etag element from XML
* @param text String
* @return etag
*/
gchar* get_etag(gchar* text);
/**
* Fetch any element from XML
* @param text String
* @return element
*/
gchar* get_tag(const gchar* tag, gchar* text);
/**
* rebuild a raw URL with https if needed from the settings
* @param settings caldav_settings
* @return URL
*/
gchar* rebuild_url(caldav_settings* setting, gchar* uri);
/**
* Prepare a curl connection
* @param settings caldav_settings
* @return CURL
*/
CURL* get_curl(caldav_settings* setting);
#endif

995
src/caldav.c
Unescape View File

@ -0,0 +1,995 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "caldav.h"
#include "caldav-utils.h"
#include "get-caldav-report.h"
#include "add-caldav-object.h"
#include "delete-caldav-object.h"
#include "modify-caldav-object.h"
#include "get-display-name.h"
#include "options-caldav-server.h"
#include "get-freebusy-report.h"
#include <curl/curl.h>
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static void init_runtime(runtime_info* info) {
if (! info)
return;
if (! info->error)
info->error = g_new0(caldav_error, 1);
if (! info->options) {
info->options = g_new0(debug_curl, 1);
info->options->trace_ascii = 1;
info->options->debug = 0;
info->options->verify_ssl_certificate = TRUE;
info->options->use_locking = TRUE;
info->options->custom_cacert = NULL;
}
}
/**
* @param curl An instance of libcurl.
* @param settings Defines CalDAV resource. Receiver is responsible for freeing
* the memory. URL is part of the structure. [http://][username:password@]host[:port]/url-path.
* See (RFC1738).
* @return FALSE (zero) mens URL does not reference a CalDAV calendar
* resource. TRUE if the URL does reference a CalDAV calendar resource.
*/
static gboolean test_caldav_enabled(CURL* curl,
caldav_settings* settings,
caldav_error* error) {
return caldav_getoptions(curl, settings, NULL, error, TRUE);
}
/*
* @param settings An instance of caldav_settings. @see caldav_settings
* @return TRUE if there was an error. Error can be in libcurl, in libcaldav,
* or an error related to the CalDAV protocol.
*/
static gboolean make_caldav_call(caldav_settings* settings,
runtime_info* info) {
CURL* curl;
gboolean result = FALSE;
g_return_val_if_fail(info != NULL, TRUE);
curl = get_curl(settings);
if (!curl) {
info->error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
if (!test_caldav_enabled(curl, settings, info->error)) {
g_free(settings->file);
settings->file = NULL;
curl_easy_cleanup(curl);
return TRUE;
}
curl_easy_cleanup(curl);
switch (settings->ACTION) {
case GETALL: result = caldav_getall(settings, info->error); break;
case GET: result = caldav_getrange(settings, info->error); break;
case GETALLTASKS: result = caldav_tasks_getall(settings, info->error); break;
case GETTASKS: result = caldav_tasks_getrange(settings, info->error); break;
case ADD: result = caldav_add(settings, info->error); break;
case DELETE: result = caldav_delete(settings, info->error); break;
case MODIFY: result = caldav_modify(settings, info->error); break;
case DELETETASKS: result = caldav_tasks_delete(settings, info->error); break;
case MODIFYTASKS: result = caldav_tasks_modify(settings, info->error); break;
case GETCALNAME: result = caldav_getname(settings, info->error); break;
case FREEBUSY: result = caldav_freebusy(settings, info->error); break;
default: break;
}
return result;
}
/**
* Function for adding a new event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_add_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = ADD;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for deleting an event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_delete_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = DELETE;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for modifying an event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_modify_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = MODIFY;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for getting a collection of events determined by time range.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start and end for range. Both
* are included in range.
* @param end time_t variable specifying start and end for range. Both
* are included in range.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_object(response *result,
time_t start,
time_t end,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = GET;
settings.start = start;
settings.end = end;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for getting all events from the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_getall_object(response* result,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = GETALL;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for deleting a task.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_delete_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = DELETETASKS;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for modifying a task.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_modify_object(const char* object,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
settings.file = g_strdup(object);
settings.ACTION = MODIFYTASKS;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for getting a collection of tasks determined by time range.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start and end for range. Both
* are included in range.
* @param end time_t variable specifying start and end for range. Both
* are included in range.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_get_object(response *result,
time_t start,
time_t end,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = GETTASKS;
settings.start = start;
settings.end = end;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for getting all tasks from the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_getall_object(response* result,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = GETALLTASKS;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function for getting the stored display name for the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_displayname(response* result,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = GETCALNAME;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function to test wether a calendar resource is CalDAV enabled or not.
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @result 0 (zero) means no CalDAV support, otherwise CalDAV support
* detechted.
*/
int caldav_enabled_resource(const char* URL, runtime_info* info) {
CURL* curl;
caldav_settings settings;
struct config_data data;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
init_caldav_settings(&settings);
parse_url(&settings, URL);
curl = get_curl(&settings);
if (!curl) {
info->error->code = -1;
info->error->str = g_strdup("Could not initialize libcurl");
settings.file = NULL;
return TRUE;
}
if (info->options->trace_ascii)
data.trace_ascii = 1;
else
data.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
if (info->options->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gboolean res = test_caldav_enabled(curl, &settings, info->error);
free_caldav_settings(&settings);
curl_easy_cleanup(curl);
return (res && (info->error->code == 0 || info->error->code == 200)) ? 1 : 0;
}
/**
* Function for getting free/busy information.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start and end for range. Both
* are included in range.
* @param end time_t variable specifying start and end for range. Both
* are included in range.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_freebusy(response *result,
time_t start,
time_t end,
const char* URL,
runtime_info* info) {
caldav_settings settings;
CALDAV_RESPONSE caldav_response;
g_return_val_if_fail(info != NULL, TRUE);
init_runtime(info);
if (!result) {
result = malloc(sizeof(response *));
memset(result, '\0', sizeof(response *));
}
init_caldav_settings(&settings);
settings.ACTION = FREEBUSY;
settings.start = start;
settings.end = end;
if (info->options->debug)
settings.debug = TRUE;
else
settings.debug = FALSE;
if (info->options->trace_ascii)
settings.trace_ascii = 1;
else
settings.trace_ascii = 0;
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
parse_url(&settings, URL);
gboolean res = make_caldav_call(&settings, info);
if (res) {
result->msg = NULL;
if (info->error->code > 0) {
switch (info->error->code) {
case 403: caldav_response = FORBIDDEN; break;
case 409: caldav_response = CONFLICT; break;
case 423: caldav_response = LOCKED; break;
case 501: caldav_response = NOTIMPLEMENTED; break;
default: caldav_response = CONFLICT; break;
}
}
else {
/* fall-back to conflicting state */
caldav_response = CONFLICT;
}
}
else {
result->msg = g_strdup(settings.file);
caldav_response = OK;
}
free_caldav_settings(&settings);
return caldav_response;
}
/**
* Function which supports sending various options inside the library.
* @param curl_options A struct debug_curl. See debug_curl.
*/
void caldav_set_options(debug_curl curl_options) {
}
/**
* @deprecated Function to call in case of errors.
* Caller provides a pointer to a local caldav_error structure.
* Caldav_get_error will initialize pointer if NULL.
* Caller is responsible for freeing returned memory.
* After the first call the internal error buffer is reset.
* @param lib_error A pointer to a struct _caldav_error. @see _caldav_error
* @return An initialized caldav_error pointer to memory where error
* messages can be found from the last call to the library.
*/
caldav_error* caldav_get_error(caldav_error* lib_error) {
if (!lib_error) {
lib_error = g_new0(caldav_error, 1);
}
return lib_error;
}
/**
* Function for freeing memory for a previous initialization of a
* caldav_error. @see caldav_get_error()
* Caller provides a pointer to a local caldav_error structure.
* @param lib_error A pointer to a struct _caldav_error. @see _caldav_error
*/
void caldav_free_error(caldav_error* lib_error) {
if (lib_error->str)
g_free(lib_error->str);
g_free(lib_error);
lib_error = NULL;
}
/**
* Function to call to get a list of supported CalDAV options for a server
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @result A list of available options or NULL in case of any error.
*/
char** caldav_get_server_options(const char* URL, runtime_info* info) {
CURL* curl;
caldav_settings settings;
response server_options;
gchar** option_list = NULL;
gchar** tmp;
gboolean res = FALSE;
g_return_val_if_fail(info != NULL, NULL);
init_runtime(info);
tmp = option_list = NULL;
init_caldav_settings(&settings);
parse_url(&settings, URL);
curl = get_curl(&settings);
if (!curl) {
info->error->code = -1;
info->error->str = g_strdup("Could not initialize libcurl");
settings.file = NULL;
return NULL;
}
if (info->options->use_locking)
settings.use_locking = 1;
else
settings.use_locking = 0;
res = caldav_getoptions(curl, &settings, &server_options, info->error, FALSE);
if (res) {
if (server_options.msg) {
option_list = g_strsplit(server_options.msg, ", ", 0);
tmp = &(*(option_list));
while (*tmp) {
g_strstrip(*tmp++);
}
}
}
free_caldav_settings(&settings);
curl_easy_cleanup(curl);
return (option_list) ? option_list : NULL;
}
/**
* Function for getting an initialized runtime_info structure
* @return runtime_info. @see runtime_info
*/
runtime_info* caldav_get_runtime_info() {
runtime_info* rt_info;
rt_info = g_new0(runtime_info, 1);
rt_info->error = g_new0(caldav_error, 1);
rt_info->options = g_new0(debug_curl, 1);
return rt_info;
}
/**
* Function for freeing memory for a previous initialization of an info
* structure
* @param info Address to a pointer to a runtime_info structure. @see
* runtime_info
*/
void caldav_free_runtime_info(runtime_info** info) {
runtime_info* ri;
if (*info) {
ri = *info;
if (ri->error) {
if (ri->error->str)
g_free(ri->error->str);
g_free(ri->error);
ri->error = NULL;
}
if (ri->options) {
if (ri->options->custom_cacert)
g_free(ri->options->custom_cacert);
g_free(ri->options);
ri->options = NULL;
}
g_free(ri);
*info = ri = NULL;
}
}
/**
* Function for getting an initialized response structure
* @return response. @see _response
*/
response* caldav_get_response() {
response* r;
r = g_new0(response, 1);
return r;
}
/**
* Function for freeing memory for a previous initialization of an response
* structure
* @param info Address to a pointer to a response structure. @see
* _response
*/
void caldav_free_response(response** resp) {
response* r;
if (*resp) {
r = *resp;
if (r->msg)
g_free(r->msg);
g_free(r);
*resp = r = NULL;
}
}

407
src/caldav.h
Unescape View File

@ -0,0 +1,407 @@
/* vim: set textwidth=80 tabstop=4: */
/**
* @file caldav.h
* @brief interface to the caldav library.
* The library conforms to RFC4791. For further information follow this
* link http://www.ietf.org/rfc/rfc4791.txt
*/
/**
* @mainpage
* This document is the documentation for the public interface to libcaldav.
* If you want to study the implementation look for the developers API.
*
* The libray and documentation is Copyright (c) 2008 Michael Rasmussen
* (mir@datanom.net)
*
* License for the source code.
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* License for the documentation.
*
* Permission is granted to copy, distribute and/or modify this document
* under the terms of the GNU Free Documentation License, Version 1.2
* or any later version published by the Free Software Foundation;
* with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
* Texts.
*/
#ifndef __CALDAV_H__
#define __CALDAV_H__
#include <time.h>
/* For debug purposes */
/**
* @typedef struct debug_curl
* A struct used to set internal options in the library
*/
typedef struct {
int trace_ascii; /** @var int trace_ascii
* 0 or 1
*/
int debug; /** @var int debug
* 0 or 1
*/
int verify_ssl_certificate;
int use_locking;
char* custom_cacert;
} debug_curl;
/**
* @typedef struct _caldav_error caldav_error
* Pointer to a caldav_error structure
*/
typedef struct _caldav_error caldav_error;
/**
* @struct _caldav_error
* A struct for storing error codes and messages
*/
struct _caldav_error {
long code; /**
* @var long code
* if < 0 internal error > 0 CalDAV protocol error.
*/
char* str; /** @var char* str
* For storing human readable error message
*/
};
/**
* @typedef struct runtime_info
* Pointer to a runtime structure holding debug and error information
*/
typedef struct {
caldav_error* error;
debug_curl* options;
} runtime_info;
/* CalDAV is defined in RFC4791 */
/* Buffer to hold response */
/**
* @typedef struct _response response
* Pointer to a _response structure
*/
typedef struct _response response;
/**
* @struct _response
* A struct used for returning messages from the library to users
*/
struct _response {
char* msg; /** @var char* msg
* String for storing response
*/
};
/**
* @enum CALDAV_ACTION specifies supported CalDAV actions.
* UNKNOWN. An unknown action.
* ADD. Add a CalDAV calendar object.
* DELETE. Delete a CalDAV calendar object.
* MODIFY. Modify a CalDAV calendar object.
* GET. Get one or more CalDAV calendar object(s).
* GETALL. Get all CalDAV calendar objects.
*/
typedef enum {
UNKNOWN,
ADD,
DELETE,
FREEBUSY,
MODIFY,
GET,
GETALL,
GETCALNAME,
ISCALDAV,
OPTIONS,
DELETETASKS,
MODIFYTASKS,
GETTASKS,
GETALLTASKS,
} CALDAV_ACTION;
/**
* @enum CALDAV_RESPONSE specifies CalDAV error states.
* OK (HTTP 200). Request was satisfied.
* FORBIDDEN (HTTP 403). Access not allowed. Dont repeat request.
* CONFLICT (HTTP 409). Conflict between current state of CalDAV collection
* and request. Client must solve the conflict and then resend request.
* LOCKED (HTTP 423). Locking failed.
*/
typedef enum {
OK,
FORBIDDEN,
CONFLICT,
LOCKED,
NOTIMPLEMENTED
} CALDAV_RESPONSE;
#ifndef __CALDAV_USERAGENT
#define __CALDAV_USERAGENT "libcurl-agent/0.1"
#endif
/**
* Function for adding a new event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_add_object(const char* object,
const char* URL,
runtime_info* info);
/**
* Function for deleting an event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_delete_object(const char* object,
const char* URL,
runtime_info* info);
/**
* Function for modifying an event.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_modify_object(const char* object,
const char* URL,
runtime_info* info);
/**
* Function for getting a collection of events determined by time range.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start for range. Included in search.
* @param end time_t variable specifying end for range. Included in search.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_object(response* result,
time_t start,
time_t end,
const char* URL,
runtime_info* info);
/**
* Function for getting all events from the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_getall_object(response* result,
const char* URL,
runtime_info* info);
/**
* Function for deleting a task.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_delete_object(const char* object,
const char* URL,
runtime_info* info);
/**
* Function for modifying a task.
* @param object Appointment following ICal format (RFC2445). Receiver is
* responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_modify_object(const char* object,
const char* URL,
runtime_info* info);
/**
* Function for getting a collection of tasks determined by time range.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start for range. Included in search.
* @param end time_t variable specifying end for range. Included in search.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_get_object(response* result,
time_t start,
time_t end,
const char* URL,
runtime_info* info);
/**
* Function for getting all tasks from the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_tasks_getall_object(response* result,
const char* URL,
runtime_info* info);
/**
* Function for getting the stored display name for the collection.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_displayname(response* result,
const char* URL,
runtime_info* info);
/**
* Function to test wether a calendar resource is CalDAV enabled or not.
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @result 0 (zero) means no CalDAV support, otherwise CalDAV support
* detechted.
*/
int caldav_enabled_resource(const char* URL, runtime_info* info);
/**
* Function for getting free/busy information.
* @param result A pointer to struct _response where the result is to stored.
* @see response. Caller is responsible for freeing the memory.
* @param start time_t variable specifying start and end for range. Both
* are included in range.
* @param end time_t variable specifying start and end for range. Both
* are included in range.
* @param URL Defines CalDAV resource. Receiver is responsible for freeing
* the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @return Ok, FORBIDDEN, or CONFLICT. @see CALDAV_RESPONSE
*/
CALDAV_RESPONSE caldav_get_freebusy(response *result,
time_t start,
time_t end,
const char* URL,
runtime_info* info);
/**
* @deprecated Always returns an initialized empty caldav_error
* Function to call in case of errors.
* Caller provides a pointer to a local caldav_error structure.
* Caldav_get_error will initialize pointer if NULL.
* Caller is responsible for freeing returned memory.
* After the first call the internal error buffer is reset.
* @param lib_error A pointer to a struct _caldav_error. @see _caldav_error
* @return An initialized caldav_error pointer to memory where error
* messages can be found from the last call to the library.
*/
caldav_error* caldav_get_error(caldav_error* lib_error);
/**
* Function for freeing memory for a previous initialization of a
* caldav_error. @see caldav_get_error()
* Caller provides a pointer to a local caldav_error structure.
* @param lib_error A pointer to a struct _caldav_error. @see _caldav_error
*/
void caldav_free_error(caldav_error* lib_error);
/* Setting various options in library */
/**
* @deprecated Does nothing
* Function which supports sending various options inside the library.
* @param curl_options A struct debug_curl. See debug_curl.
*/
void caldav_set_options(debug_curl curl_options);
/**
* Function to call to get a list of supported CalDAV options for a server
* @param URL Defines CalDAV resource. Receiver is responsible for
* freeing the memory. [http://][username[:password]@]host[:port]/url-path.
* See (RFC1738).
* @param info Pointer to a runtime_info structure. @see runtime_info
* @result A list of available options or NULL in case of any error.
*/
char** caldav_get_server_options(const char* URL, runtime_info* info);
/**
* Function for getting an initialized runtime_info structure
* @return runtime_info. @see runtime_info
*/
runtime_info* caldav_get_runtime_info();
/**
* Function for freeing memory for a previous initialization of an info
* structure
* @param info Address to a pointer to a runtime_info structure. @see
* runtime_info
*/
void caldav_free_runtime_info(runtime_info** info);
/**
* Function for getting an initialized response structure
* @return response. @see _response
*/
response* caldav_get_response();
/**
* Function for freeing memory for a previous initialization of an response
* structure
* @param info Address to a pointer to a response structure. @see
* _response
*/
void caldav_free_response(response** info);
#endif

533
src/delete-caldav-object.c
Unescape View File

@ -0,0 +1,533 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "delete-caldav-object.h"
#include "lock-caldav-object.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the first part of the calendar query.
* The actual UID to use for the query is added at runtime.
*/
static char* search_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VEVENT\">"
" <C:prop-filter name=\"UID\">";
/**
* A static literal string containing the first part of the calendar query.
* The actual UID to use for the query is added at runtime.
*/
static char* search_tasks_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VTODO\">"
" <C:prop-filter name=\"UID\">";
/**
* A static literal string containing the last part of the calendar query
*/
static char* search_tail =
"</C:prop-filter>"
" </C:comp-filter>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>";
/**
* Function for deleting an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_delete(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* search;
gchar* uid;
gboolean LOCKSUPPORT = FALSE;
gchar* lock_token = NULL;
gboolean result = FALSE;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: infinity");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* file = g_strdup(settings->file);
if ((uid = get_response_header("uid", file, FALSE)) == NULL) {
g_free(file);
error->code = 1;
error->str = g_strdup("Error: Missing required UID for object");
return TRUE;
}
g_free(file);
/*
* ICalendar server does not support collation
* <C:text-match collation=\"i;ascii-casemap\">%s</C:text-match>
*/
search = g_strdup_printf(
"%s\r\n<C:text-match>%s</C:text-match>\r\n%s",
search_head, uid, search_tail);
g_free(uid);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, search);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(search));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
g_free(search);
curl_slist_free_all(http_header);
http_header = NULL;
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
else {
/* enable uploading */
gchar* url = NULL;
gchar* etag = NULL;
url = get_url(chunk.memory);
if (url) {
etag = get_etag(chunk.memory);
if (etag) {
gchar* host = get_host(settings->url);
if (host) {
file = g_strdup(url);
g_free(url);
url = g_strdup_printf("%s%s", host, file);
g_free(file);
g_free(host);
}
else {
g_free(etag);
g_free(url);
url = NULL;
}
}
else {
g_free(url);
url = NULL;
}
}
if (url) {
int lock = 0;
caldav_error lock_error;
file = g_strdup(etag);
g_free(etag);
etag = g_strdup_printf("If-Match: %s", file);
g_free(file);
http_header = curl_slist_append(http_header, etag);
g_free(etag);
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(
http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
if (settings->use_locking)
LOCKSUPPORT = caldav_lock_support(settings, &lock_error);
else
LOCKSUPPORT = FALSE;
if (LOCKSUPPORT) {
lock_token = caldav_lock_object(url, settings, &lock_error);
if (lock_token) {
http_header = curl_slist_append(
http_header, g_strdup_printf(
"If: (%s)", lock_token));
}
/*
* If error code is 423 (Resource is LOCKED) bail out
*/
else if (lock_error.code == 423) {
lock = -1;
}
/*
* If error code is 501 (Not implemented) we continue
* hoping for the best.
*/
else if (lock_error.code == 501) {
lock_token = g_strdup("");
}
else {
lock = -1;
}
}
if (! LOCKSUPPORT || (LOCKSUPPORT && lock_token && lock_error.code != 423)) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_URL, rebuild_url(settings, url));
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, 0);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (LOCKSUPPORT && lock_token) {
caldav_unlock_object(
lock_token, url, settings, &lock_error);
}
}
g_free(url);
g_free(lock_token);
if (res != 0 || lock < 0) {
/* Is this a lock_error don't change error*/
if (lock == 0 || lock_error.code == 423) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
error->code = lock_error.code;
error->str = g_strdup(lock_error.str);
}
result = TRUE;
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(
curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
}
curl_slist_free_all(http_header);
}
else {
error->code = code;
if (chunk.memory)
error->str = g_strdup(chunk.memory);
else
error->str = g_strdup("No object found");
result = TRUE;
}
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}
/**
* Function for deleting a task.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_tasks_delete(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* search;
gchar* uid;
gboolean LOCKSUPPORT = FALSE;
gchar* lock_token = NULL;
gboolean result = FALSE;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: infinity");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* file = g_strdup(settings->file);
if ((uid = get_response_header("uid", file, FALSE)) == NULL) {
g_free(file);
error->code = 1;
error->str = g_strdup("Error: Missing required UID for object");
return TRUE;
}
g_free(file);
/*
* ICalendar server does not support collation
* <C:text-match collation=\"i;ascii-casemap\">%s</C:text-match>
*/
search = g_strdup_printf(
"%s\r\n<C:text-match>%s</C:text-match>\r\n%s",
search_tasks_head, uid, search_tail);
g_free(uid);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, search);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(search));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
g_free(search);
curl_slist_free_all(http_header);
http_header = NULL;
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
else {
/* enable uploading */
gchar* url = NULL;
gchar* etag = NULL;
url = get_url(chunk.memory);
if (url) {
etag = get_etag(chunk.memory);
if (etag) {
gchar* host = get_host(settings->url);
if (host) {
file = g_strdup(url);
g_free(url);
url = g_strdup_printf("%s%s", host, file);
g_free(file);
g_free(host);
}
else {
g_free(etag);
g_free(url);
url = NULL;
}
}
else {
g_free(url);
url = NULL;
}
}
if (url) {
int lock = 0;
caldav_error lock_error;
file = g_strdup(etag);
g_free(etag);
etag = g_strdup_printf("If-Match: %s", file);
g_free(file);
http_header = curl_slist_append(http_header, etag);
g_free(etag);
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(
http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
if (settings->use_locking)
LOCKSUPPORT = caldav_lock_support(settings, &lock_error);
else
LOCKSUPPORT = FALSE;
if (LOCKSUPPORT) {
lock_token = caldav_lock_object(url, settings, &lock_error);
if (lock_token) {
http_header = curl_slist_append(
http_header, g_strdup_printf(
"If: (%s)", lock_token));
}
/*
* If error code is 423 (Resource is LOCKED) bail out
*/
else if (lock_error.code == 423) {
lock = -1;
}
/*
* If error code is 501 (Not implemented) we continue
* hoping for the best.
*/
else if (lock_error.code == 501) {
lock_token = g_strdup("");
}
else {
lock = -1;
}
}
if (! LOCKSUPPORT || (LOCKSUPPORT && lock_token && lock_error.code != 423)) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_URL, rebuild_url(settings, url));
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, 0);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (LOCKSUPPORT && lock_token) {
caldav_unlock_object(
lock_token, url, settings, &lock_error);
}
}
g_free(url);
g_free(lock_token);
if (res != 0 || lock < 0) {
/* Is this a lock_error don't change error*/
if (lock == 0 || lock_error.code == 423) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
error->code = lock_error.code;
error->str = g_strdup(lock_error.str);
}
result = TRUE;
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(
curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
}
curl_slist_free_all(http_header);
}
else {
error->code = code;
if (chunk.memory)
error->str = g_strdup(chunk.memory);
else
error->str = g_strdup("No object found");
result = TRUE;
}
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}

43
src/delete-caldav-object.h
Unescape View File

@ -0,0 +1,43 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __DELETE_CALDAV_OBJECT_H__
#define __DELETE_CALDAV_OBJECT_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function for deleting an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_delete(caldav_settings* settings, caldav_error* error);
/**
* Function for deleting a task.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_tasks_delete(caldav_settings* settings, caldav_error* error);
#endif

472
src/get-caldav-report.c
Unescape View File

@ -0,0 +1,472 @@
/* vim: set textwidth=80 tabstop=4 smarttab: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "get-caldav-report.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the calendar query for fetching
* all events from collection.
*/
static const char* getall_request =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VEVENT\"/>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>\r\n";
/**
* A static literal string containing the first part of the calendar query.
* The actual VEVENT to search for is added at runtime.
*/
static const char* getrange_request_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
/*"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"*/
"<C:calendar-query xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop xmlns:D=\"DAV:\">"
/*" <D:getetag/>"*/
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VEVENT\">";
/**
* A static literal string containing the last part of the calendar query
*/
static const char* getrange_request_foot =
" </C:comp-filter>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>\r\n";
/**
* A static literal string containing the calendar query for fetching
* all tasks from collection.
*/
static const char* getall_tasks_request =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VTODO\"/>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>\r\n";
/**
* A static literal string containing the first part of the calendar query.
* The actual VTODO to search for is added at runtime.
*/
static const char* getrange_tasks_request_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
/*"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"*/
"<C:calendar-query xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop xmlns:D=\"DAV:\">"
/*" <D:getetag/>"*/
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VTODO\">";
/**
* Function for getting all events from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getall(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, getall_request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(getall_request));
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(headers.memory);
result = TRUE;
}
else {
gchar* report;
report = parse_caldav_report(
chunk.memory, "calendar-data", "VEVENT");
settings->file = g_strdup(report);
g_free(report);
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}
/**
* Function for getting all events within a time range from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getrange(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE + 1];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
gchar* request = NULL;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
request = g_strdup_printf(
"%s\r\n<C:time-range start=\"%s\"\r\n end=\"%s\"/>\r\n%s",
getrange_request_head, get_caldav_datetime(&settings->start),
get_caldav_datetime(&settings->end), getrange_request_foot);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(request));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
gchar* report;
report = parse_caldav_report(chunk.memory, "calendar-data", "VEVENT");
settings->file = g_strdup(report);
g_free(report);
}
g_free(request);
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}
/**
* Function for getting all tasks from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_tasks_getall(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, getall_tasks_request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(getall_tasks_request));
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(headers.memory);
result = TRUE;
}
else {
gchar* report;
report = parse_caldav_report(
chunk.memory, "calendar-data", "VTODO");
settings->file = g_strdup(report);
g_free(report);
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}
/**
* Function for getting all events within a time range from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_tasks_getrange(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE + 1];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
gchar* request = NULL;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
request = g_strdup_printf(
"%s\r\n<C:time-range start=\"%s\"\r\n end=\"%s\"/>\r\n%s",
getrange_tasks_request_head, get_caldav_datetime(&settings->start),
get_caldav_datetime(&settings->end), getrange_request_foot);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(request));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
gchar* report;
report = parse_caldav_report(chunk.memory, "calendar-data", "VTODO");
settings->file = g_strdup(report);
g_free(report);
}
g_free(request);
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}

59
src/get-caldav-report.h
Unescape View File

@ -0,0 +1,59 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GET_CALDAV_REPORT_H__
#define __GET_CALDAV_REPORT_H__
#include "caldav-utils.h"
#include "caldav.h"
#include <glib.h>
/**
* Function for getting all events from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getall(caldav_settings* settings, caldav_error* error);
/**
* Function for getting all events within a time range from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getrange(caldav_settings* settings, caldav_error* error);
/**
* Function for getting all tasks from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_tasks_getall(caldav_settings* settings, caldav_error* error);
/**
* Function for getting all tasks within a time range from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_tasks_getrange(caldav_settings* settings, caldav_error* error);
#endif

139
src/get-display-name.c
Unescape View File

@ -0,0 +1,139 @@
/* vim: set textwidth=80 tabstop=4 smarttab: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "get-caldav-report.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the calendar query for fetching
* the stored display name for the collection.
*/
static const char* getname_request =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<D:propfind xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:displayname/>"
" </D:prop>"
"</D:propfind>\r\n";
/**
* Function for getting the display name from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getname(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 0");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, getname_request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(getname_request));
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PROPFIND");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(headers.memory);
result = TRUE;
}
else {
gchar* displayname;
displayname = get_tag("displayname", chunk.memory);
/* Maybe namespace prefixed */
if (!displayname) {
displayname = get_tag("D:displayname", chunk.memory);
}
settings->file = (displayname) ?
g_strdup(displayname) : g_strdup("");
g_free(displayname);
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}

34
src/get-display-name.h
Unescape View File

@ -0,0 +1,34 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GET_DISPLAY_NAME_H__
#define __GET_DISPLAY_NAME_H__
#include "caldav-utils.h"
/**
* Function for getting the display name from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_getname(caldav_settings* settings, caldav_error* error);
#endif

140
src/get-freebusy-report.c
Unescape View File

@ -0,0 +1,140 @@
/* vim: set textwidth=80 tabstop=4 smarttab: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "get-freebusy-report.h"
#include <glib.h>
#include <curl/curl.h>
#include <string.h>
/**
* A static literal string containing the first part of the calendar query.
* The actual VEVENT to search for is added at runtime.
*/
static const char* getrange_request_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:free-busy-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">";
/**
* A static literal string containing the last part of the calendar query
*/
static const char* getrange_request_foot =
"</C:free-busy-query>\r\n";
/**
* Function for getting freebusy within a time range from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_freebusy(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE + 1];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
gchar* request = NULL;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
request = g_strdup_printf(
"%s\r\n<C:time-range start=\"%s\"\r\n end=\"%s\"/>\r\n%s",
getrange_request_head, get_caldav_datetime(&settings->start),
get_caldav_datetime(&settings->end), getrange_request_foot);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, request);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(request));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 200) {
error->code = code;
error->str = g_strdup(headers.memory);
result = TRUE;
}
else {
/*gchar* report;
report = parse_caldav_report(chunk.memory, "calendar-data", "VFREEBUSY");
settings->file = g_strdup(report);*/
settings->file = g_strdup(chunk.memory);
/*g_free(report);*/
}
}
g_free(request);
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_slist_free_all(http_header);
curl_easy_cleanup(curl);
return result;
}

35
src/get-freebusy-report.h
Unescape View File

@ -0,0 +1,35 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __GET_FREEBUSY_REPORT_H__
#define __GET_FREEBUSY_REPORT_H__
#include "caldav-utils.h"
#include "caldav.h"
#include <glib.h>
/**
* Function for getting freebusy within a time range from collection.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_freebusy(caldav_settings* settings, caldav_error* error);
#endif

292
src/lock-caldav-object.c
Unescape View File

@ -0,0 +1,292 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "lock-caldav-object.h"
#include "options-caldav-server.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the lock query.
*/
static char* lock_query =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<D:lockinfo xmlns:D=\"DAV:\">"
" <D:lockscope><D:exclusive/></D:lockscope>"
" <D:locktype><D:write/></D:locktype>"
"</D:lockinfo>";
/**
* Function which requests a lock on a calendar resource
* @param URI The resource to request lock on.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return The Lock-Token or NULL in case of error
*/
gchar* caldav_lock_object(
gchar* URI, caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* lock_token = NULL;
gchar* url;
if (! caldav_lock_support(settings, error))
return lock_token;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return lock_token;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Timeout: Second-300");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
if (settings->usehttps) {
url = g_strdup_printf("https://%s", URI);
} else {
url = g_strdup_printf("http://%s", URI);
}
curl_easy_setopt(curl, CURLOPT_URL, url);
g_free(url);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, lock_query);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(lock_query));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "LOCK");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
curl_slist_free_all(http_header);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 200) {
gchar* status = get_tag("status", chunk.memory);
if (status && strstr(status, "423") != NULL) {
error->code = 423;
error->str = g_strdup(status);
}
else {
error->code = code;
error->str = g_strdup(chunk.memory);
}
g_free(status);
}
else {
lock_token = get_response_header(
"Lock-Token", headers.memory, FALSE);
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return lock_token;
}
/**
* Function which requests to have a lock removed from a calendar resource
* @param lock_token A privious aquired Lock-Token
* @param URI The resource to request unlock on.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return False in case the lock could not be removed. True otherwise.
*/
gboolean caldav_unlock_object(gchar* lock_token, gchar* URI,
caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gboolean result = FALSE;
gchar* url;
if (! caldav_lock_support(settings, error))
return result;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
g_strdup_printf("Lock-Token: %s", lock_token));
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
if (settings->usehttps) {
url = g_strdup_printf("https://%s", URI);
} else {
url = g_strdup_printf("http://%s", URI);
}
curl_easy_setopt(curl, CURLOPT_URL, url);
g_free(url);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "UNLOCK");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
curl_slist_free_all(http_header);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
result = TRUE;
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}
/**
* Function to test whether the server supports locking or not. Searching
* for PROP LOCK. If LOCK is present then according to RFC4791 PROP UNLOCK
* must also be present.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return True if locking is supported by the server. False otherwise
*/
gboolean caldav_lock_support(caldav_settings* settings, caldav_error* error) {
gboolean found = FALSE;
gchar* url = NULL;
gchar* mystr = NULL;
runtime_info* info;
info = caldav_get_runtime_info();
info->options->verify_ssl_certificate = settings->verify_ssl_certificate;
info->options->custom_cacert = g_strdup(settings->custom_cacert);
if (settings->usehttps) {
mystr = g_strdup("https://");
} else {
mystr = g_strdup("http://");
}
if (settings->username && settings->password) {
url = g_strdup_printf("%s%s:%s@%s",
mystr, settings->username, settings->password, settings->url);
}
else if (settings->username) {
url = g_strdup_printf("%s%s@%s",
mystr, settings->username, settings->url);
}
else {
url = g_strdup_printf("%s%s", mystr, settings->url);
}
gchar** options = caldav_get_server_options(url, info);
g_free(url);
gchar** tmp = options;
caldav_free_runtime_info(&info);
while (*options) {
if (strcmp(*options++, "LOCK") == 0) {
found = TRUE;
break;
}
}
g_strfreev(tmp);
g_free(mystr);
return found;
}

55
src/lock-caldav-object.h
Unescape View File

@ -0,0 +1,55 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __LOCK_CALDAV_OBJECT_H__
#define __LOCK_CALDAV_OBJECT_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function which requests a lock on a calendar resource
* @param URI The resource to request lock on.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return The Lock-Token or NULL in case of error
*/
gchar* caldav_lock_object(
gchar* URI, caldav_settings* settings, caldav_error* error);
/**
* Function which requests to have a lock removed from a calendar resource
* @param lock_token A privious aquired Lock-Token
* @param URI The resource to request unlock on.
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return False in case the lock could not be removed. True otherwise.
*/
gboolean caldav_unlock_object(gchar* lock_token, gchar* URI,
caldav_settings* settings, caldav_error* error);
/**
* Function to test whether the server supports locking or not
* @param settings @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return True if locking is supported by the server. False otherwise
*/
gboolean caldav_lock_support(caldav_settings* settings, caldav_error* error);
#endif

442
src/md5.c
Unescape View File

@ -0,0 +1,442 @@
/** md5.c - MD5 Message-Digest Algorithm
* Copyright (C) 1995, 1996, 1998, 1999 Free Software Foundation, Inc.
*
* according to the definition of MD5 in RFC 1321 from April 1992.
* NOTE: This is *not* the same file as the one from glibc.
*
* 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, 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 <http://www.gnu.org/licenses/>.
*
* Written by Ulrich Drepper <drepper@gnu.ai.mit.edu>, 1995.
* heavily modified for GnuPG by <werner.koch@guug.de>.
* modified again for Sylpheed by <wk@gnupg.org> 2001-02-11.
*/
/* Test values:
* "" D4 1D 8C D9 8F 00 B2 04 E9 80 09 98 EC F8 42 7E
* "a" 0C C1 75 B9 C0 F1 B6 A8 31 C3 99 E2 69 77 26 61
* "abc 90 01 50 98 3C D2 4F B0 D6 96 3F 7D 28 E1 7F 72
* "message digest" F9 6B 69 7D 7C B7 93 8D 52 5A 2F 31 AA F1 61 D0
*/
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "md5.h"
/****************
* Rotate a 32 bit integer by n bytes
*/
#if defined(__GNUC__) && defined(__i386__)
static inline u32
rol( u32 x, int n)
{
__asm__("roll %%cl,%0"
:"=r" (x)
:"0" (x),"c" (n));
return x;
}
#else
#define rol(x,n) ( ((x) << (n)) | ((x) >> (32-(n))) )
#endif
static void
md5_init(MD5_CONTEXT *ctx)
{
ctx->A = 0x67452301;
ctx->B = 0xefcdab89;
ctx->C = 0x98badcfe;
ctx->D = 0x10325476;
ctx->nblocks = 0;
ctx->count = 0;
ctx->finalized = 0;
}
/* These are the four functions used in the four steps of the MD5 algorithm
and defined in the RFC 1321. The first function is a little bit optimized
(as found in Colin Plumbs public domain implementation). */
/* #define FF(b, c, d) ((b & c) | (~b & d)) */
#define FF(b, c, d) (d ^ (b & (c ^ d)))
#define FG(b, c, d) FF (d, b, c)
#define FH(b, c, d) (b ^ c ^ d)
#define FI(b, c, d) (c ^ (b | ~d))
/****************
* transform n*64 bytes
*/
static void
transform(MD5_CONTEXT *ctx, const unsigned char *data)
{
u32 correct_words[16];
u32 A = ctx->A;
u32 B = ctx->B;
u32 C = ctx->C;
u32 D = ctx->D;
u32 *cwp = correct_words;
#ifdef BIG_ENDIAN_HOST
{
int i;
unsigned char *p2;
const unsigned char *p1;
for (i = 0, p1 = data, p2 = (unsigned char*)correct_words;
i < 16; i++, p2 += 4) {
p2[3] = *p1++;
p2[2] = *p1++;
p2[1] = *p1++;
p2[0] = *p1++;
}
}
#else
memcpy(correct_words, data, 64);
#endif
#define OP(a, b, c, d, s, T) \
do { \
a += FF (b, c, d) + (*cwp++) + T; \
a = rol(a, s); \
a += b; \
} while (0)
/* Before we start, one word about the strange constants.
They are defined in RFC 1321 as
T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
*/
/* Round 1. */
OP (A, B, C, D, 7, 0xd76aa478);
OP (D, A, B, C, 12, 0xe8c7b756);
OP (C, D, A, B, 17, 0x242070db);
OP (B, C, D, A, 22, 0xc1bdceee);
OP (A, B, C, D, 7, 0xf57c0faf);
OP (D, A, B, C, 12, 0x4787c62a);
OP (C, D, A, B, 17, 0xa8304613);
OP (B, C, D, A, 22, 0xfd469501);
OP (A, B, C, D, 7, 0x698098d8);
OP (D, A, B, C, 12, 0x8b44f7af);
OP (C, D, A, B, 17, 0xffff5bb1);
OP (B, C, D, A, 22, 0x895cd7be);
OP (A, B, C, D, 7, 0x6b901122);
OP (D, A, B, C, 12, 0xfd987193);
OP (C, D, A, B, 17, 0xa679438e);
OP (B, C, D, A, 22, 0x49b40821);
#undef OP
#define OP(f, a, b, c, d, k, s, T) \
do { \
a += f (b, c, d) + correct_words[k] + T; \
a = rol(a, s); \
a += b; \
} while (0)
/* Round 2. */
OP (FG, A, B, C, D, 1, 5, 0xf61e2562);
OP (FG, D, A, B, C, 6, 9, 0xc040b340);
OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa);
OP (FG, A, B, C, D, 5, 5, 0xd62f105d);
OP (FG, D, A, B, C, 10, 9, 0x02441453);
OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8);
OP (FG, A, B, C, D, 9, 5, 0x21e1cde6);
OP (FG, D, A, B, C, 14, 9, 0xc33707d6);
OP (FG, C, D, A, B, 3, 14, 0xf4d50d87);
OP (FG, B, C, D, A, 8, 20, 0x455a14ed);
OP (FG, A, B, C, D, 13, 5, 0xa9e3e905);
OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8);
OP (FG, C, D, A, B, 7, 14, 0x676f02d9);
OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
/* Round 3. */
OP (FH, A, B, C, D, 5, 4, 0xfffa3942);
OP (FH, D, A, B, C, 8, 11, 0x8771f681);
OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
OP (FH, A, B, C, D, 1, 4, 0xa4beea44);
OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9);
OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60);
OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
OP (FH, A, B, C, D, 13, 4, 0x289b7ec6);
OP (FH, D, A, B, C, 0, 11, 0xeaa127fa);
OP (FH, C, D, A, B, 3, 16, 0xd4ef3085);
OP (FH, B, C, D, A, 6, 23, 0x04881d05);
OP (FH, A, B, C, D, 9, 4, 0xd9d4d039);
OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
OP (FH, B, C, D, A, 2, 23, 0xc4ac5665);
/* Round 4. */
OP (FI, A, B, C, D, 0, 6, 0xf4292244);
OP (FI, D, A, B, C, 7, 10, 0x432aff97);
OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
OP (FI, B, C, D, A, 5, 21, 0xfc93a039);
OP (FI, A, B, C, D, 12, 6, 0x655b59c3);
OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92);
OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
OP (FI, B, C, D, A, 1, 21, 0x85845dd1);
OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f);
OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
OP (FI, C, D, A, B, 6, 15, 0xa3014314);
OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
OP (FI, A, B, C, D, 4, 6, 0xf7537e82);
OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb);
OP (FI, B, C, D, A, 9, 21, 0xeb86d391);
/* Put checksum in context given as argument. */
ctx->A += A;
ctx->B += B;
ctx->C += C;
ctx->D += D;
}
/* The routine updates the message-digest context to
* account for the presence of each of the characters inBuf[0..inLen-1]
* in the message whose digest is being computed.
*/
static void
md5_update(MD5_CONTEXT *hd, const unsigned char *inbuf, size_t inlen)
{
if (hd->count == 64) { /* flush the buffer */
transform( hd, hd->buf );
hd->count = 0;
hd->nblocks++;
}
if (!inbuf)
return;
if (hd->count) {
for (; inlen && hd->count < 64; inlen--)
hd->buf[hd->count++] = *inbuf++;
md5_update(hd, NULL, 0);
if (!inlen)
return;
}
while (inlen >= 64) {
transform(hd, inbuf);
hd->count = 0;
hd->nblocks++;
inlen -= 64;
inbuf += 64;
}
for (; inlen && hd->count < 64; inlen--)
hd->buf[hd->count++] = *inbuf++;
}
/* The routine final terminates the message-digest computation and
* ends with the desired message digest in mdContext->digest[0...15].
* The handle is prepared for a new MD5 cycle.
* Returns 16 bytes representing the digest.
*/
static void
do_final(MD5_CONTEXT *hd)
{
u32 t, msb, lsb;
unsigned char *p;
md5_update(hd, NULL, 0); /* flush */
msb = 0;
t = hd->nblocks;
if ((lsb = t << 6) < t) /* multiply by 64 to make a byte count */
msb++;
msb += t >> 26;
t = lsb;
if ((lsb = t + hd->count) < t) /* add the count */
msb++;
t = lsb;
if ((lsb = t << 3) < t) /* multiply by 8 to make a bit count */
msb++;
msb += t >> 29;
if (hd->count < 56) { /* enough room */
hd->buf[hd->count++] = 0x80; /* pad */
while(hd->count < 56)
hd->buf[hd->count++] = 0; /* pad */
} else { /* need one extra block */
hd->buf[hd->count++] = 0x80; /* pad character */
while (hd->count < 64)
hd->buf[hd->count++] = 0;
md5_update(hd, NULL, 0); /* flush */
memset(hd->buf, 0, 56); /* fill next block with zeroes */
}
/* append the 64 bit count */
hd->buf[56] = lsb ;
hd->buf[57] = lsb >> 8;
hd->buf[58] = lsb >> 16;
hd->buf[59] = lsb >> 24;
hd->buf[60] = msb ;
hd->buf[61] = msb >> 8;
hd->buf[62] = msb >> 16;
hd->buf[63] = msb >> 24;
transform(hd, hd->buf);
p = hd->buf;
#ifdef BIG_ENDIAN_HOST
#define X(a) do { *p++ = hd->a ; *p++ = hd->a >> 8; \
*p++ = hd->a >> 16; *p++ = hd->a >> 24; } while(0)
#else /* little endian */
/*#define X(a) do { *(u32*)p = hd->##a ; p += 4; } while(0)*/
/* Unixware's cpp doesn't like the above construct so we do it his way:
* (reported by Allan Clark) */
#define X(a) do { *(u32*)p = (*hd).a ; p += 4; } while(0)
#endif
X(A);
X(B);
X(C);
X(D);
#undef X
hd->finalized = 1;
}
static void
md5_final(unsigned char *digest, MD5_CONTEXT *ctx)
{
if (!ctx->finalized)
do_final(ctx);
memcpy(digest, ctx->buf, 16);
}
/*
* Creates a MD5 digest in hex fomrat (lowercase letters) from the
* string S. hextdigest but be buffer of at lease 33 bytes!
*/
static void
md5_hex_digest(char *hexdigest, const unsigned char *s)
{
int i;
MD5_CONTEXT context;
unsigned char digest[16];
md5_init(&context);
md5_update(&context, s, strlen((gchar *) s));
md5_final(digest, &context);
for (i = 0; i < 16; i++)
sprintf(hexdigest + 2 * i, "%02x", digest[i]);
}
/*
** Function: md5_hmac
** taken from the file rfc2104.txt
** written by Martin Schaaf <mascha@ma-scha.de>
*/
static void
md5_hmac(unsigned char *digest,
const unsigned char* text, int text_len,
const unsigned char* key, int key_len)
{
MD5_CONTEXT context;
unsigned char k_ipad[64]; /* inner padding -
* key XORd with ipad
*/
unsigned char k_opad[64]; /* outer padding -
* key XORd with opad
*/
/* unsigned char tk[16]; */
int i;
/* start out by storing key in pads */
memset(k_ipad, 0, sizeof k_ipad);
memset(k_opad, 0, sizeof k_opad);
if (key_len > 64) {
/* if key is longer than 64 bytes reset it to key=MD5(key) */
MD5_CONTEXT tctx;
md5_init(&tctx);
md5_update(&tctx, key, key_len);
md5_final(k_ipad, &tctx);
md5_final(k_opad, &tctx);
} else {
memcpy(k_ipad, key, key_len);
memcpy(k_opad, key, key_len);
}
/*
* the HMAC_MD5 transform looks like:
*
* MD5(K XOR opad, MD5(K XOR ipad, text))
*
* where K is an n byte key
* ipad is the byte 0x36 repeated 64 times
* opad is the byte 0x5c repeated 64 times
* and text is the data being protected
*/
/* XOR key with ipad and opad values */
for (i = 0; i < 64; i++) {
k_ipad[i] ^= 0x36;
k_opad[i] ^= 0x5c;
}
/*
* perform inner MD5
*/
md5_init(&context); /* init context for 1st
* pass */
md5_update(&context, k_ipad, 64); /* start with inner pad */
md5_update(&context, text, text_len); /* then text of datagram */
md5_final(digest, &context); /* finish up 1st pass */
/*
* perform outer MD5
*/
md5_init(&context); /* init context for 2nd
* pass */
md5_update(&context, k_opad, 64); /* start with outer pad */
md5_update(&context, digest, 16); /* then results of 1st
* hash */
md5_final(digest, &context); /* finish up 2nd pass */
}
static void
md5_hex_hmac(char *hexdigest,
const unsigned char* text, int text_len,
const unsigned char* key, int key_len)
{
unsigned char digest[16];
int i;
md5_hmac(digest, text, text_len, key, key_len);
for (i = 0; i < 16; i++)
sprintf(hexdigest + 2 * i, "%02x", digest[i]);
}
void caldav_md5_hex_digest(char *hexdigest, const unsigned char *s) {
md5_hex_digest(hexdigest, s);
}
void caldav_md5_hex_hmac(char *hexdigest,
const unsigned char* text, int text_len,
const unsigned char* key, int key_len) {
md5_hex_hmac(hexdigest, text, text_len, key, key_len);
}

52
src/md5.h
Unescape View File

@ -0,0 +1,52 @@
/**
* md5.h - MD5 Message-Digest Algorithm
* Copyright (C) 1995, 1996, 1998, 1999 Free Software Foundation, Inc.
*
* according to the definition of MD5 in RFC 1321 from April 1992.
* NOTE: This is *not* the same file as the one from glibc
*
* 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, 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 <http://www.gnu.org/licenses/>.
*/
#ifndef _MD5_HDR_
#define _MD5_HDR_
#include <glib.h>
/**
* @typedef u32
* Kept this typedef for compatibility reasons
*/
#ifndef HAVE_U32_TYPEDEF
#undef u32
typedef guint32 u32;
#define HAVE_U32_TYPEDEF
#endif
typedef struct { /* Hmm, should be private */
u32 A,B,C,D;
u32 nblocks;
unsigned char buf[64];
int count;
int finalized;
} MD5_CONTEXT;
void caldav_md5_hex_digest(char *hexdigest, const unsigned char *s);
void caldav_md5_hex_hmac(char *hexdigest,
const unsigned char* text, int text_len,
const unsigned char* key, int key_len);
#endif /* _MD5_HDR_ */

555
src/modify-caldav-object.c
Unescape View File

@ -0,0 +1,555 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "modify-caldav-object.h"
#include "lock-caldav-object.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* A static literal string containing the first part of the calendar query.
* The actual UID to use for the query is added at runtime.
*/
static char* search_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VEVENT\">"
" <C:prop-filter name=\"UID\">";
/**
* A static literal string containing the first part of the calendar query.
* The actual UID to use for the query is added at runtime.
*/
static char* search_tasks_head =
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
"<C:calendar-query xmlns:D=\"DAV:\""
" xmlns:C=\"urn:ietf:params:xml:ns:caldav\">"
" <D:prop>"
" <D:getetag/>"
" <C:calendar-data/>"
" </D:prop>"
" <C:filter>"
" <C:comp-filter name=\"VCALENDAR\">"
" <C:comp-filter name=\"VTODO\">"
" <C:prop-filter name=\"UID\">";
/**
* A static literal string containing the last part of the calendar query
*/
static char* search_tail =
"</C:prop-filter>"
" </C:comp-filter>"
" </C:comp-filter>"
" </C:filter>"
"</C:calendar-query>";
/**
* Function for modifying an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_modify(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* search;
gchar* uid;
gboolean result = FALSE;
gboolean LOCKSUPPORT = FALSE;
gchar* lock_token = NULL;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* file = g_strdup(settings->file);
if ((uid = get_response_header("uid", file, FALSE)) == NULL) {
g_free(file);
error->code = 1;
error->str = g_strdup("Error: Missing required UID for object");
return TRUE;
}
g_free(file);
/*
* collation is not supported by ICalendar.
* <C:text-match collation=\"i;ascii-casemap\">%s</C:text-match>
*/
search = g_strdup_printf(
"%s\r\n<C:text-match>%s</C:text-match>\r\n%s",
search_head, uid, search_tail);
g_free(uid);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, search);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(search));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
curl_slist_free_all(http_header);
http_header = NULL;
g_free(search);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
else {
/* enable uploading */
gchar* url = NULL;
gchar* etag = NULL;
url = get_url(chunk.memory);
if (url) {
etag = get_etag(chunk.memory);
if (etag) {
gchar* host = get_host(settings->url);
if (host) {
file = g_strdup(url);
g_free(url);
url = g_strdup_printf("%s%s", host, file);
g_free(file);
g_free(host);
}
else {
g_free(etag);
g_free(url);
url = NULL;
}
}
else {
g_free(url);
url = NULL;
}
if (url) {
int lock = 0;
caldav_error lock_error;
file = g_strdup(etag);
g_free(etag);
etag = g_strdup_printf("If-Match: %s", file);
g_free(file);
http_header = curl_slist_append(http_header, etag);
g_free(etag);
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(
http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
if (settings->use_locking)
LOCKSUPPORT = caldav_lock_support(settings, &lock_error);
else
LOCKSUPPORT = FALSE;
if (LOCKSUPPORT) {
lock_token = caldav_lock_object(url, settings, &lock_error);
if (lock_token) {
http_header = curl_slist_append(
http_header, g_strdup_printf(
"If: (%s)", lock_token));
}
/*
* If error code is 423 (Resource is LOCKED) bail out
*/
else if (lock_error.code == 423) {
lock = -1;
}
/*
* If error code is 501 (Not implemented) we continue
* hoping for the best.
*/
else if (lock_error.code == 501) {
lock_token = g_strdup("");
}
else {
lock = -1;
}
}
if (! LOCKSUPPORT || (LOCKSUPPORT && lock_token && lock_error.code != 423)) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_URL, rebuild_url(settings, url));
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, settings->file);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE,
strlen(settings->file));
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
res = curl_easy_perform(curl);
if (LOCKSUPPORT && lock_token) {
caldav_unlock_object(
lock_token, url, settings, &lock_error);
}
}
g_free(url);
g_free(lock_token);
if (res != 0 || lock < 0) {
/* Is this a lock_error don't change error*/
if (lock == 0 || lock_error.code == 423) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
error->code = lock_error.code;
error->str = g_strdup(lock_error.str);
}
result = TRUE;
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(
curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
}
curl_slist_free_all(http_header);
}
else {
error->code = code;
if (chunk.memory)
error->str = g_strdup(chunk.memory);
else
error->str = g_strdup("No object found");
result = TRUE;
}
}
else {
/*
* No object found on server. Posible synchronization
* problem or a server side race condition
*/
error->code = 409;
error->str = g_strdup("No object found");
result = TRUE;
}
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}
/**
* Function for modifying a task.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_tasks_modify(caldav_settings* settings, caldav_error* error) {
CURL* curl;
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct config_data data;
struct MemoryStruct chunk;
struct MemoryStruct headers;
struct curl_slist *http_header = NULL;
gchar* search;
gchar* uid;
gboolean result = FALSE;
gboolean LOCKSUPPORT = FALSE;
gchar* lock_token = NULL;
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
curl = get_curl(settings);
if (!curl) {
error->code = -1;
error->str = g_strdup("Could not initialize libcurl");
g_free(settings->file);
settings->file = NULL;
return TRUE;
}
http_header = curl_slist_append(http_header,
"Content-Type: application/xml; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Depth: 1");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
data.trace_ascii = settings->trace_ascii;
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'headers' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
if (settings->debug) {
curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, my_trace);
curl_easy_setopt(curl, CURLOPT_DEBUGDATA, &data);
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
}
gchar* file = g_strdup(settings->file);
if ((uid = get_response_header("uid", file, FALSE)) == NULL) {
g_free(file);
error->code = 1;
error->str = g_strdup("Error: Missing required UID for object");
return TRUE;
}
g_free(file);
/*
* collation is not supported by ICalendar.
* <C:text-match collation=\"i;ascii-casemap\">%s</C:text-match>
*/
search = g_strdup_printf(
"%s\r\n<C:text-match>%s</C:text-match>\r\n%s",
search_tasks_head, uid, search_tail);
g_free(uid);
/* enable uploading */
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, search);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE, strlen(search));
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "REPORT");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
curl_slist_free_all(http_header);
http_header = NULL;
g_free(search);
if (res != 0) {
error->code = -1;
error->str = g_strdup_printf("%s", error_buf);
g_free(settings->file);
settings->file = NULL;
result = TRUE;
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 207) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
else {
/* enable uploading */
gchar* url = NULL;
gchar* etag = NULL;
url = get_url(chunk.memory);
if (url) {
etag = get_etag(chunk.memory);
if (etag) {
gchar* host = get_host(settings->url);
if (host) {
file = g_strdup(url);
g_free(url);
url = g_strdup_printf("%s%s", host, file);
g_free(file);
g_free(host);
}
else {
g_free(etag);
g_free(url);
url = NULL;
}
}
else {
g_free(url);
url = NULL;
}
if (url) {
int lock = 0;
caldav_error lock_error;
file = g_strdup(etag);
g_free(etag);
etag = g_strdup_printf("If-Match: %s", file);
g_free(file);
http_header = curl_slist_append(http_header, etag);
g_free(etag);
http_header = curl_slist_append(http_header,
"Content-Type: text/calendar; charset=\"utf-8\"");
http_header = curl_slist_append(http_header, "Expect:");
http_header = curl_slist_append(
http_header, "Transfer-Encoding:");
http_header = curl_slist_append(http_header, "Connection: close");
if (settings->use_locking)
LOCKSUPPORT = caldav_lock_support(settings, &lock_error);
else
LOCKSUPPORT = FALSE;
if (LOCKSUPPORT) {
lock_token = caldav_lock_object(url, settings, &lock_error);
if (lock_token) {
http_header = curl_slist_append(
http_header, g_strdup_printf(
"If: (%s)", lock_token));
}
/*
* If error code is 423 (Resource is LOCKED) bail out
*/
else if (lock_error.code == 423) {
lock = -1;
}
/*
* If error code is 501 (Not implemented) we continue
* hoping for the best.
*/
else if (lock_error.code == 501) {
lock_token = g_strdup("");
}
else {
lock = -1;
}
}
if (! LOCKSUPPORT || (LOCKSUPPORT && lock_token && lock_error.code != 423)) {
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_header);
curl_easy_setopt(curl, CURLOPT_URL, rebuild_url(settings, url));
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, settings->file);
curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE,
strlen(settings->file));
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
res = curl_easy_perform(curl);
if (LOCKSUPPORT && lock_token) {
caldav_unlock_object(
lock_token, url, settings, &lock_error);
}
}
g_free(url);
g_free(lock_token);
if (res != 0 || lock < 0) {
/* Is this a lock_error don't change error*/
if (lock == 0 || lock_error.code == 423) {
error->code = code;
error->str = g_strdup(chunk.memory);
}
else {
error->code = lock_error.code;
error->str = g_strdup(lock_error.str);
}
result = TRUE;
g_free(settings->file);
settings->file = NULL;
}
else {
long code;
res = curl_easy_getinfo(
curl, CURLINFO_RESPONSE_CODE, &code);
if (code != 204) {
error->code = code;
error->str = g_strdup(chunk.memory);
result = TRUE;
}
}
curl_slist_free_all(http_header);
}
else {
error->code = code;
if (chunk.memory)
error->str = g_strdup(chunk.memory);
else
error->str = g_strdup("No object found");
result = TRUE;
}
}
else {
/*
* No object found on server. Posible synchronization
* problem or a server side race condition
*/
error->code = 409;
error->str = g_strdup("No object found");
result = TRUE;
}
}
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_cleanup(curl);
return result;
}

42
src/modify-caldav-object.h
Unescape View File

@ -0,0 +1,42 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __MODIFY_CALDAV_OBJECT_H__
#define __MODIFY_CALDAV_OBJECT_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function for modifying an event.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_modify(caldav_settings* settings, caldav_error* error);
/**
* Function for modifying a task.
* @param settings A pointer to caldav_settings. @see caldav_settings
* @param error A pointer to caldav_error. @see caldav_error
* @return TRUE in case of error, FALSE otherwise.
*/
gboolean caldav_tasks_modify(caldav_settings* settings, caldav_error* error);
#endif

135
src/options-caldav-server.c
Unescape View File

@ -0,0 +1,135 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "options-caldav-server.h"
#include <glib.h>
#include <curl/curl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/**
* Function for getting supported options from a server.
* @param curl A pointer to an initialized CURL instance
* @param settings struct containing the URL to the server. If authentication
* is required prior to making the call the credentials must be available
* via CURLOPT_USERPWD before calling.
* @param result A pointer to a struct _response. If test is true
* this variable can be NULL. Caller is responsible for freeing associated
* memory.
* @param error A pointer to caldav_error. @see caldav_error
* @param test if this is true response will be whether the server
* represented by the URL is a CalDAV collection or not.
* @return FALSE in case of error, TRUE otherwise.
*/
gboolean caldav_getoptions(CURL* curl, caldav_settings* settings, response* result,
caldav_error* error, gboolean test) {
CURLcode res = 0;
char error_buf[CURL_ERROR_SIZE];
struct MemoryStruct chunk;
struct MemoryStruct headers;
gboolean enabled = FALSE;
if (! curl)
return FALSE;
if (!error) {
error = (caldav_error *) malloc(sizeof(struct _caldav_error));
memset(error, '\0', sizeof(struct _caldav_error));
}
chunk.memory = NULL; /* we expect realloc(NULL, size) to work */
chunk.size = 0; /* no data at this point */
headers.memory = NULL;
headers.size = 0;
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunk);
/* send all data to this function */
curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, WriteHeaderCallback);
/* we pass our 'chunk' struct to the callback function */
curl_easy_setopt(curl, CURLOPT_WRITEHEADER, (void *)&headers);
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, (char *) &error_buf);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "OPTIONS");
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(curl, CURLOPT_UNRESTRICTED_AUTH, 1);
curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
res = curl_easy_perform(curl);
if (res == 0) {
gchar* head;
head = get_response_header("DAV", headers.memory, TRUE);
if (head && strstr(head, "calendar-access") != NULL) {
enabled = TRUE;
if (! test) {
result->msg = g_strdup(
get_response_header("Allow", headers.memory, FALSE));
}
}
else {
long code;
res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
if (code == 200) {
error->code = -1;
error->str = g_strdup("URL is not a CalDAV resource");
}
else {
error->code = -1 * code;
error->str = g_strdup(headers.memory);
}
}
g_free(head);
}
else if (
(res == CURLE_SSL_CONNECT_ERROR ||
CURLE_PEER_FAILED_VERIFICATION ||
CURLE_SSL_ENGINE_NOTFOUND ||
CURLE_SSL_ENGINE_SETFAILED ||
CURLE_SSL_CERTPROBLEM ||
CURLE_SSL_CIPHER ||
CURLE_SSL_CACERT ||
CURLE_SSL_CACERT_BADFILE ||
CURLE_SSL_CRL_BADFILE ||
CURLE_SSL_ISSUER_ERROR) && settings->usehttps) {
error->code = -2;
error->str = g_strdup(error_buf);
}
else if (res == CURLE_COULDNT_RESOLVE_HOST) {
error->code = -3;
error->str = g_strdup("Could not resolve host");
}
else if (res == CURLE_COULDNT_CONNECT) {
error->code = -4;
error->str = g_strdup("Unable to connect");
}
else {
error->code = -1;
error->str = g_strdup("URL is not a CalDAV resource");
}
if (chunk.memory)
free(chunk.memory);
if (headers.memory)
free(headers.memory);
curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "GET");
return enabled;
}

43
src/options-caldav-server.h
Unescape View File

@ -0,0 +1,43 @@
/* vim: set textwidth=80 tabstop=4: */
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef __OPTIONS_CALDAV_SERVER_H__
#define __OPTIONS_CALDAV_SERVER_H__
#include "caldav-utils.h"
#include "caldav.h"
/**
* Function for getting supported options from a server.
* @param curl A pointer to an initialized CURL instance
* @param settings struct containing the URL to the server. If authentication
* is required prior to making the call the credentials must be available
* via CURLOPT_USERPWD before calling.
* @param result A pointer to a struct _response. If test is true
* this variable can be NULL. Caller is responsible for freeing associated
* memory.
* @param error A pointer to caldav_error. @see caldav_error
* @param test if this is true response will be whether the server
* represented by the URL is a CalDAV collection or not.
* @return FALSE in case of error, TRUE otherwise.
*/
gboolean caldav_getoptions(CURL* curl, caldav_settings* settings, response* result,
caldav_error* error, gboolean test);
#endif

17
test/.svn/all-wcprops
Unescape View File

@ -0,0 +1,17 @@
K 25
svn:wc:ra_dav:version-url
V 41
/svnroot/libcaldav/!svn/ver/42/trunk/test
END
Makefile.in
K 25
svn:wc:ra_dav:version-url
V 53
/svnroot/libcaldav/!svn/ver/42/trunk/test/Makefile.in
END
Makefile.am
K 25
svn:wc:ra_dav:version-url
V 53
/svnroot/libcaldav/!svn/ver/30/trunk/test/Makefile.am
END

105
test/.svn/entries
Unescape View File

@ -0,0 +1,105 @@
10
dir
42
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav/trunk/test
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav
2010-05-29T15:45:56.236020Z
42
miras
6bb92309-7149-0410-b568-bc30dfd0a1d5
unittest
dir
Makefile.in
file
2010-05-31T07:07:58.000000Z
fa74e0a0a67b25662dfd0dd6ed1f78a3
2010-05-29T15:45:56.236020Z
42
miras
17836
src
dir
Makefile.am
file
2010-05-31T07:07:58.000000Z
49c7239729ed3197c7e08cb1f51b4545
2010-04-04T20:17:57.156621Z
30
miras
82
ics
dir

8
test/.svn/text-base/Makefile.am.svn-base
Unescape View File

@ -0,0 +1,8 @@
AUTOMAKE_OPTIONS = gnu
SUBDIRS = \
ics \
src \
unittest
EXTRA_DIST =

597
test/.svn/text-base/Makefile.in.svn-base
Unescape View File

@ -0,0 +1,597 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = test
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
SOURCES =
DIST_SOURCES =
RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
html-recursive info-recursive install-data-recursive \
install-dvi-recursive install-exec-recursive \
install-html-recursive install-info-recursive \
install-pdf-recursive install-ps-recursive install-recursive \
installcheck-recursive installdirs-recursive pdf-recursive \
ps-recursive uninstall-recursive
RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
distclean-recursive maintainer-clean-recursive
AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \
$(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \
distdir
ETAGS = etags
CTAGS = ctags
DIST_SUBDIRS = $(SUBDIRS)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
am__relativize = \
dir0=`pwd`; \
sed_first='s,^\([^/]*\)/.*$$,\1,'; \
sed_rest='s,^[^/]*/*,,'; \
sed_last='s,^.*/\([^/]*\)$$,\1,'; \
sed_butlast='s,/*[^/]*$$,,'; \
while test -n "$$dir1"; do \
first=`echo "$$dir1" | sed -e "$$sed_first"`; \
if test "$$first" != "."; then \
if test "$$first" = ".."; then \
dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
else \
first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
if test "$$first2" = "$$first"; then \
dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
else \
dir2="../$$dir2"; \
fi; \
dir0="$$dir0"/"$$first"; \
fi; \
fi; \
dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
done; \
reldir="$$dir2"
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
SUBDIRS = \
ics \
src \
unittest
EXTRA_DIST =
all: all-recursive
.SUFFIXES:
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu test/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu test/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
# This directory's subdirectories are mostly independent; you can cd
# into them and run `make' without going through this Makefile.
# To change the values of `make' variables: instead of editing Makefiles,
# (1) if the variable is set in `config.status', edit `config.status'
# (which will cause the Makefiles to be regenerated when you run `make');
# (2) otherwise, pass the desired values on the `make' command line.
$(RECURSIVE_TARGETS):
@fail= failcom='exit 1'; \
for f in x $$MAKEFLAGS; do \
case $$f in \
*=* | --[!k]*);; \
*k*) failcom='fail=yes';; \
esac; \
done; \
dot_seen=no; \
target=`echo $@ | sed s/-recursive//`; \
list='$(SUBDIRS)'; for subdir in $$list; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
dot_seen=yes; \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done; \
if test "$$dot_seen" = "no"; then \
$(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
fi; test -z "$$fail"
$(RECURSIVE_CLEAN_TARGETS):
@fail= failcom='exit 1'; \
for f in x $$MAKEFLAGS; do \
case $$f in \
*=* | --[!k]*);; \
*k*) failcom='fail=yes';; \
esac; \
done; \
dot_seen=no; \
case "$@" in \
distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
*) list='$(SUBDIRS)' ;; \
esac; \
rev=''; for subdir in $$list; do \
if test "$$subdir" = "."; then :; else \
rev="$$subdir $$rev"; \
fi; \
done; \
rev="$$rev ."; \
target=`echo $@ | sed s/-recursive//`; \
for subdir in $$rev; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done && test -z "$$fail"
tags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
done
ctags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
done
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
include_option=--etags-include; \
empty_fix=.; \
else \
include_option=--include; \
empty_fix=; \
fi; \
list='$(SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test ! -f $$subdir/TAGS || \
set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
fi; \
done; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test -d "$(distdir)/$$subdir" \
|| $(MKDIR_P) "$(distdir)/$$subdir" \
|| exit 1; \
fi; \
done
@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
$(am__relativize); \
new_distdir=$$reldir; \
dir1=$$subdir; dir2="$(top_distdir)"; \
$(am__relativize); \
new_top_distdir=$$reldir; \
echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
($(am__cd) $$subdir && \
$(MAKE) $(AM_MAKEFLAGS) \
top_distdir="$$new_top_distdir" \
distdir="$$new_distdir" \
am__remove_distdir=: \
am__skip_length_check=: \
am__skip_mode_fix=: \
distdir) \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-recursive
all-am: Makefile
installdirs: installdirs-recursive
installdirs-am:
install: install-recursive
install-exec: install-exec-recursive
install-data: install-data-recursive
uninstall: uninstall-recursive
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-recursive
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-recursive
clean-am: clean-generic clean-libtool mostlyclean-am
distclean: distclean-recursive
-rm -f Makefile
distclean-am: clean-am distclean-generic distclean-tags
dvi: dvi-recursive
dvi-am:
html: html-recursive
html-am:
info: info-recursive
info-am:
install-data-am:
install-dvi: install-dvi-recursive
install-dvi-am:
install-exec-am:
install-html: install-html-recursive
install-html-am:
install-info: install-info-recursive
install-info-am:
install-man:
install-pdf: install-pdf-recursive
install-pdf-am:
install-ps: install-ps-recursive
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-recursive
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-recursive
mostlyclean-am: mostlyclean-generic mostlyclean-libtool
pdf: pdf-recursive
pdf-am:
ps: ps-recursive
ps-am:
uninstall-am:
.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) ctags-recursive \
install-am install-strip tags-recursive
.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \
all all-am check check-am clean clean-generic clean-libtool \
ctags ctags-recursive distclean distclean-generic \
distclean-libtool distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-man install-pdf install-pdf-am \
install-ps install-ps-am install-strip installcheck \
installcheck-am installdirs installdirs-am maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-generic \
mostlyclean-libtool pdf pdf-am ps ps-am tags tags-recursive \
uninstall uninstall-am
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

8
test/Makefile.am
Unescape View File

@ -0,0 +1,8 @@
AUTOMAKE_OPTIONS = gnu
SUBDIRS = \
ics \
src \
unittest
EXTRA_DIST =

597
test/Makefile.in
Unescape View File

@ -0,0 +1,597 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = test
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
SOURCES =
DIST_SOURCES =
RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
html-recursive info-recursive install-data-recursive \
install-dvi-recursive install-exec-recursive \
install-html-recursive install-info-recursive \
install-pdf-recursive install-ps-recursive install-recursive \
installcheck-recursive installdirs-recursive pdf-recursive \
ps-recursive uninstall-recursive
RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
distclean-recursive maintainer-clean-recursive
AM_RECURSIVE_TARGETS = $(RECURSIVE_TARGETS:-recursive=) \
$(RECURSIVE_CLEAN_TARGETS:-recursive=) tags TAGS ctags CTAGS \
distdir
ETAGS = etags
CTAGS = ctags
DIST_SUBDIRS = $(SUBDIRS)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
am__relativize = \
dir0=`pwd`; \
sed_first='s,^\([^/]*\)/.*$$,\1,'; \
sed_rest='s,^[^/]*/*,,'; \
sed_last='s,^.*/\([^/]*\)$$,\1,'; \
sed_butlast='s,/*[^/]*$$,,'; \
while test -n "$$dir1"; do \
first=`echo "$$dir1" | sed -e "$$sed_first"`; \
if test "$$first" != "."; then \
if test "$$first" = ".."; then \
dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
else \
first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
if test "$$first2" = "$$first"; then \
dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
else \
dir2="../$$dir2"; \
fi; \
dir0="$$dir0"/"$$first"; \
fi; \
fi; \
dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
done; \
reldir="$$dir2"
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
SUBDIRS = \
ics \
src \
unittest
EXTRA_DIST =
all: all-recursive
.SUFFIXES:
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu test/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu test/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
# This directory's subdirectories are mostly independent; you can cd
# into them and run `make' without going through this Makefile.
# To change the values of `make' variables: instead of editing Makefiles,
# (1) if the variable is set in `config.status', edit `config.status'
# (which will cause the Makefiles to be regenerated when you run `make');
# (2) otherwise, pass the desired values on the `make' command line.
$(RECURSIVE_TARGETS):
@fail= failcom='exit 1'; \
for f in x $$MAKEFLAGS; do \
case $$f in \
*=* | --[!k]*);; \
*k*) failcom='fail=yes';; \
esac; \
done; \
dot_seen=no; \
target=`echo $@ | sed s/-recursive//`; \
list='$(SUBDIRS)'; for subdir in $$list; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
dot_seen=yes; \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done; \
if test "$$dot_seen" = "no"; then \
$(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
fi; test -z "$$fail"
$(RECURSIVE_CLEAN_TARGETS):
@fail= failcom='exit 1'; \
for f in x $$MAKEFLAGS; do \
case $$f in \
*=* | --[!k]*);; \
*k*) failcom='fail=yes';; \
esac; \
done; \
dot_seen=no; \
case "$@" in \
distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
*) list='$(SUBDIRS)' ;; \
esac; \
rev=''; for subdir in $$list; do \
if test "$$subdir" = "."; then :; else \
rev="$$subdir $$rev"; \
fi; \
done; \
rev="$$rev ."; \
target=`echo $@ | sed s/-recursive//`; \
for subdir in $$rev; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done && test -z "$$fail"
tags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
done
ctags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
done
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
include_option=--etags-include; \
empty_fix=.; \
else \
include_option=--include; \
empty_fix=; \
fi; \
list='$(SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test ! -f $$subdir/TAGS || \
set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
fi; \
done; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test -d "$(distdir)/$$subdir" \
|| $(MKDIR_P) "$(distdir)/$$subdir" \
|| exit 1; \
fi; \
done
@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
$(am__relativize); \
new_distdir=$$reldir; \
dir1=$$subdir; dir2="$(top_distdir)"; \
$(am__relativize); \
new_top_distdir=$$reldir; \
echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
echo " am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
($(am__cd) $$subdir && \
$(MAKE) $(AM_MAKEFLAGS) \
top_distdir="$$new_top_distdir" \
distdir="$$new_distdir" \
am__remove_distdir=: \
am__skip_length_check=: \
am__skip_mode_fix=: \
distdir) \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-recursive
all-am: Makefile
installdirs: installdirs-recursive
installdirs-am:
install: install-recursive
install-exec: install-exec-recursive
install-data: install-data-recursive
uninstall: uninstall-recursive
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-recursive
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-recursive
clean-am: clean-generic clean-libtool mostlyclean-am
distclean: distclean-recursive
-rm -f Makefile
distclean-am: clean-am distclean-generic distclean-tags
dvi: dvi-recursive
dvi-am:
html: html-recursive
html-am:
info: info-recursive
info-am:
install-data-am:
install-dvi: install-dvi-recursive
install-dvi-am:
install-exec-am:
install-html: install-html-recursive
install-html-am:
install-info: install-info-recursive
install-info-am:
install-man:
install-pdf: install-pdf-recursive
install-pdf-am:
install-ps: install-ps-recursive
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-recursive
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-recursive
mostlyclean-am: mostlyclean-generic mostlyclean-libtool
pdf: pdf-recursive
pdf-am:
ps: ps-recursive
ps-am:
uninstall-am:
.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) ctags-recursive \
install-am install-strip tags-recursive
.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \
all all-am check check-am clean clean-generic clean-libtool \
ctags ctags-recursive distclean distclean-generic \
distclean-libtool distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-man install-pdf install-pdf-am \
install-ps install-ps-am install-strip installcheck \
installcheck-am installdirs installdirs-am maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-generic \
mostlyclean-libtool pdf pdf-am ps ps-am tags tags-recursive \
uninstall uninstall-am
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

35
test/ics/.svn/all-wcprops
Unescape View File

@ -0,0 +1,35 @@
K 25
svn:wc:ra_dav:version-url
V 45
/svnroot/libcaldav/!svn/ver/42/trunk/test/ics
END
delete.ics
K 25
svn:wc:ra_dav:version-url
V 55
/svnroot/libcaldav/!svn/ver/1/trunk/test/ics/delete.ics
END
Makefile.in
K 25
svn:wc:ra_dav:version-url
V 57
/svnroot/libcaldav/!svn/ver/42/trunk/test/ics/Makefile.in
END
modify.ics
K 25
svn:wc:ra_dav:version-url
V 55
/svnroot/libcaldav/!svn/ver/1/trunk/test/ics/modify.ics
END
add.ics
K 25
svn:wc:ra_dav:version-url
V 52
/svnroot/libcaldav/!svn/ver/1/trunk/test/ics/add.ics
END
Makefile.am
K 25
svn:wc:ra_dav:version-url
V 56
/svnroot/libcaldav/!svn/ver/1/trunk/test/ics/Makefile.am
END

198
test/ics/.svn/entries
Unescape View File

@ -0,0 +1,198 @@
10
dir
42
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav/trunk/test/ics
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav
2010-05-29T15:45:56.236020Z
42
miras
6bb92309-7149-0410-b568-bc30dfd0a1d5
delete.ics
file
2010-05-31T07:07:58.000000Z
5081183482b5b610c7c8c4ffe84e0f72
2008-03-29T18:04:01.076545Z
1
miras
271
Makefile.in
file
2010-05-31T07:07:58.000000Z
f9ecb7d37044b61240ac8b781e8bf925
2010-05-29T15:45:56.236020Z
42
miras
12899
modify.ics
file
2010-05-31T07:07:58.000000Z
c3d6c42b35a2e21843eeb0a704b6ae65
2008-03-29T18:04:01.076545Z
1
miras
271
add.ics
file
2010-05-31T07:07:58.000000Z
5081183482b5b610c7c8c4ffe84e0f72
2008-03-29T18:04:01.076545Z
1
miras
271
Makefile.am
file
2010-05-31T07:07:58.000000Z
0e5c15655892d36373113fec8da66120
2008-03-29T18:04:01.076545Z
1
miras
192

13
test/ics/.svn/text-base/Makefile.am.svn-base
Unescape View File

@ -0,0 +1,13 @@
AUTOMAKE_OPTIONS = gnu
caldav_test_filedir = $(docdir)/ics
caldav_test_file_DATA = \
add.ics \
delete.ics \
modify.ics
EXTRA_DIST = \
add.ics \
delete.ics \
modify.ics

448
test/ics/.svn/text-base/Makefile.in.svn-base
Unescape View File

@ -0,0 +1,448 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = test/ics
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
SOURCES =
DIST_SOURCES =
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__installdirs = "$(DESTDIR)$(caldav_test_filedir)"
DATA = $(caldav_test_file_DATA)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
caldav_test_filedir = $(docdir)/ics
caldav_test_file_DATA = \
add.ics \
delete.ics \
modify.ics
EXTRA_DIST = \
add.ics \
delete.ics \
modify.ics
all: all-am
.SUFFIXES:
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu test/ics/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu test/ics/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
install-caldav_test_fileDATA: $(caldav_test_file_DATA)
@$(NORMAL_INSTALL)
test -z "$(caldav_test_filedir)" || $(MKDIR_P) "$(DESTDIR)$(caldav_test_filedir)"
@list='$(caldav_test_file_DATA)'; test -n "$(caldav_test_filedir)" || list=; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
echo "$$d$$p"; \
done | $(am__base_list) | \
while read files; do \
echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(caldav_test_filedir)'"; \
$(INSTALL_DATA) $$files "$(DESTDIR)$(caldav_test_filedir)" || exit $$?; \
done
uninstall-caldav_test_fileDATA:
@$(NORMAL_UNINSTALL)
@list='$(caldav_test_file_DATA)'; test -n "$(caldav_test_filedir)" || list=; \
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
test -n "$$files" || exit 0; \
echo " ( cd '$(DESTDIR)$(caldav_test_filedir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(caldav_test_filedir)" && rm -f $$files
tags: TAGS
TAGS:
ctags: CTAGS
CTAGS:
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(DATA)
installdirs:
for dir in "$(DESTDIR)$(caldav_test_filedir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-libtool mostlyclean-am
distclean: distclean-am
-rm -f Makefile
distclean-am: clean-am distclean-generic
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am: install-caldav_test_fileDATA
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am:
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-generic mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-caldav_test_fileDATA
.MAKE: install-am install-strip
.PHONY: all all-am check check-am clean clean-generic clean-libtool \
distclean distclean-generic distclean-libtool distdir dvi \
dvi-am html html-am info info-am install install-am \
install-caldav_test_fileDATA install-data install-data-am \
install-dvi install-dvi-am install-exec install-exec-am \
install-html install-html-am install-info install-info-am \
install-man install-pdf install-pdf-am install-ps \
install-ps-am install-strip installcheck installcheck-am \
installdirs maintainer-clean maintainer-clean-generic \
mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
ps ps-am uninstall uninstall-am uninstall-caldav_test_fileDATA
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

12
test/ics/.svn/text-base/add.ics.svn-base
Unescape View File

@ -0,0 +1,12 @@
BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Example Corp.//CalDAV Client//EN
BEGIN:VEVENT
DTSTAMP:20080404T182145Z
DTSTART:20080415T151500Z
DTEND:20080415T162500Z
SUMMARY:Frodo's birthday party. Please respond.
UID:20080404T182145Z-123401@example.com
END:VEVENT
END:VCALENDAR

12
test/ics/.svn/text-base/delete.ics.svn-base
Unescape View File

@ -0,0 +1,12 @@
BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Example Corp.//CalDAV Client//EN
BEGIN:VEVENT
DTSTAMP:20080404T182145Z
DTSTART:20080415T151500Z
DTEND:20080415T162500Z
SUMMARY:Frodo's birthday party. Please respond.
UID:20080404T182145Z-123401@example.com
END:VEVENT
END:VCALENDAR

12
test/ics/.svn/text-base/modify.ics.svn-base
Unescape View File

@ -0,0 +1,12 @@
BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Example Corp.//CalDAV Client//EN
BEGIN:VEVENT
DTSTAMP:20080404T182145Z
DTSTART:20080416T151500Z
DTEND:20080416T162500Z
SUMMARY:Frodo's birthday party. Please respond.
UID:20080404T182145Z-123401@example.com
END:VEVENT
END:VCALENDAR

13
test/ics/Makefile.am
Unescape View File

@ -0,0 +1,13 @@
AUTOMAKE_OPTIONS = gnu
caldav_test_filedir = $(docdir)/ics
caldav_test_file_DATA = \
add.ics \
delete.ics \
modify.ics
EXTRA_DIST = \
add.ics \
delete.ics \
modify.ics

448
test/ics/Makefile.in
Unescape View File

@ -0,0 +1,448 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = test/ics
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
SOURCES =
DIST_SOURCES =
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__installdirs = "$(DESTDIR)$(caldav_test_filedir)"
DATA = $(caldav_test_file_DATA)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
caldav_test_filedir = $(docdir)/ics
caldav_test_file_DATA = \
add.ics \
delete.ics \
modify.ics
EXTRA_DIST = \
add.ics \
delete.ics \
modify.ics
all: all-am
.SUFFIXES:
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu test/ics/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu test/ics/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
install-caldav_test_fileDATA: $(caldav_test_file_DATA)
@$(NORMAL_INSTALL)
test -z "$(caldav_test_filedir)" || $(MKDIR_P) "$(DESTDIR)$(caldav_test_filedir)"
@list='$(caldav_test_file_DATA)'; test -n "$(caldav_test_filedir)" || list=; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
echo "$$d$$p"; \
done | $(am__base_list) | \
while read files; do \
echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(caldav_test_filedir)'"; \
$(INSTALL_DATA) $$files "$(DESTDIR)$(caldav_test_filedir)" || exit $$?; \
done
uninstall-caldav_test_fileDATA:
@$(NORMAL_UNINSTALL)
@list='$(caldav_test_file_DATA)'; test -n "$(caldav_test_filedir)" || list=; \
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
test -n "$$files" || exit 0; \
echo " ( cd '$(DESTDIR)$(caldav_test_filedir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(caldav_test_filedir)" && rm -f $$files
tags: TAGS
TAGS:
ctags: CTAGS
CTAGS:
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(DATA)
installdirs:
for dir in "$(DESTDIR)$(caldav_test_filedir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-libtool mostlyclean-am
distclean: distclean-am
-rm -f Makefile
distclean-am: clean-am distclean-generic
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am: install-caldav_test_fileDATA
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am:
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-generic mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-caldav_test_fileDATA
.MAKE: install-am install-strip
.PHONY: all all-am check check-am clean clean-generic clean-libtool \
distclean distclean-generic distclean-libtool distdir dvi \
dvi-am html html-am info info-am install install-am \
install-caldav_test_fileDATA install-data install-data-am \
install-dvi install-dvi-am install-exec install-exec-am \
install-html install-html-am install-info install-info-am \
install-man install-pdf install-pdf-am install-ps \
install-ps-am install-strip installcheck installcheck-am \
installdirs maintainer-clean maintainer-clean-generic \
mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
ps ps-am uninstall uninstall-am uninstall-caldav_test_fileDATA
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

12
test/ics/add.ics
Unescape View File

@ -0,0 +1,12 @@
BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Example Corp.//CalDAV Client//EN
BEGIN:VEVENT
DTSTAMP:20080404T182145Z
DTSTART:20080415T151500Z
DTEND:20080415T162500Z
SUMMARY:Frodo's birthday party. Please respond.
UID:20080404T182145Z-123401@example.com
END:VEVENT
END:VCALENDAR

12
test/ics/delete.ics
Unescape View File

@ -0,0 +1,12 @@
BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Example Corp.//CalDAV Client//EN
BEGIN:VEVENT
DTSTAMP:20080404T182145Z
DTSTART:20080415T151500Z
DTEND:20080415T162500Z
SUMMARY:Frodo's birthday party. Please respond.
UID:20080404T182145Z-123401@example.com
END:VEVENT
END:VCALENDAR

12
test/ics/modify.ics
Unescape View File

@ -0,0 +1,12 @@
BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Example Corp.//CalDAV Client//EN
BEGIN:VEVENT
DTSTAMP:20080404T182145Z
DTSTART:20080416T151500Z
DTEND:20080416T162500Z
SUMMARY:Frodo's birthday party. Please respond.
UID:20080404T182145Z-123401@example.com
END:VEVENT
END:VCALENDAR

23
test/src/.svn/all-wcprops
Unescape View File

@ -0,0 +1,23 @@
K 25
svn:wc:ra_dav:version-url
V 45
/svnroot/libcaldav/!svn/ver/42/trunk/test/src
END
Makefile.in
K 25
svn:wc:ra_dav:version-url
V 57
/svnroot/libcaldav/!svn/ver/42/trunk/test/src/Makefile.in
END
caldav-test.c
K 25
svn:wc:ra_dav:version-url
V 59
/svnroot/libcaldav/!svn/ver/40/trunk/test/src/caldav-test.c
END
Makefile.am
K 25
svn:wc:ra_dav:version-url
V 57
/svnroot/libcaldav/!svn/ver/30/trunk/test/src/Makefile.am
END

130
test/src/.svn/entries
Unescape View File

@ -0,0 +1,130 @@
10
dir
42
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav/trunk/test/src
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav
2010-05-29T15:45:56.236020Z
42
miras
6bb92309-7149-0410-b568-bc30dfd0a1d5
Makefile.in
file
2010-05-31T07:07:58.000000Z
5623db3c1b01fb5c13cd1e15ea763355
2010-05-29T15:45:56.236020Z
42
miras
17789
caldav-test.c
file
2010-05-31T07:07:58.000000Z
438a9b64b6a8b95695cfdf79b94f33b1
2010-05-23T21:46:08.944313Z
40
miras
10238
Makefile.am
file
2010-05-31T07:07:58.000000Z
edfdb9dbb873f21664df8048fa441106
2010-04-04T20:17:57.156621Z
30
miras
372

24
test/src/.svn/text-base/Makefile.am.svn-base
Unescape View File

@ -0,0 +1,24 @@
AUTOMAKE_OPTIONS = gnu
if BUILD_CALDAV
INCLUDES = \
@CURL_CFLAGS@ \
@GLIB_CFLAGS@ \
-I$(top_srcdir) \
-I$(top_srcdir)/src
bin_PROGRAMS = caldav-test
caldav_test_SOURCES = \
caldav-test.c
noinst_HEADERS =
caldav_test_LDFLAGS = \
-L$(top_builddir)/src
caldav_test_LDADD = \
@CURL_LIBS@ \
@GLIB_LIBS@ \
-lcaldav
endif

568
test/src/.svn/text-base/Makefile.in.svn-base
Unescape View File

@ -0,0 +1,568 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
@BUILD_CALDAV_TRUE@bin_PROGRAMS = caldav-test$(EXEEXT)
subdir = test/src
DIST_COMMON = $(noinst_HEADERS) $(srcdir)/Makefile.am \
$(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
am__installdirs = "$(DESTDIR)$(bindir)"
PROGRAMS = $(bin_PROGRAMS)
am__caldav_test_SOURCES_DIST = caldav-test.c
@BUILD_CALDAV_TRUE@am_caldav_test_OBJECTS = caldav-test.$(OBJEXT)
caldav_test_OBJECTS = $(am_caldav_test_OBJECTS)
caldav_test_DEPENDENCIES =
caldav_test_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(caldav_test_LDFLAGS) $(LDFLAGS) -o $@
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(caldav_test_SOURCES)
DIST_SOURCES = $(am__caldav_test_SOURCES_DIST)
HEADERS = $(noinst_HEADERS)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
@BUILD_CALDAV_TRUE@INCLUDES = \
@BUILD_CALDAV_TRUE@ @CURL_CFLAGS@ \
@BUILD_CALDAV_TRUE@ @GLIB_CFLAGS@ \
@BUILD_CALDAV_TRUE@ -I$(top_srcdir) \
@BUILD_CALDAV_TRUE@ -I$(top_srcdir)/src
@BUILD_CALDAV_TRUE@caldav_test_SOURCES = \
@BUILD_CALDAV_TRUE@ caldav-test.c
@BUILD_CALDAV_TRUE@noinst_HEADERS =
@BUILD_CALDAV_TRUE@caldav_test_LDFLAGS = \
@BUILD_CALDAV_TRUE@ -L$(top_builddir)/src
@BUILD_CALDAV_TRUE@caldav_test_LDADD = \
@BUILD_CALDAV_TRUE@ @CURL_LIBS@ \
@BUILD_CALDAV_TRUE@ @GLIB_LIBS@ \
@BUILD_CALDAV_TRUE@ -lcaldav
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu test/src/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu test/src/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
install-binPROGRAMS: $(bin_PROGRAMS)
@$(NORMAL_INSTALL)
test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
for p in $$list; do echo "$$p $$p"; done | \
sed 's/$(EXEEXT)$$//' | \
while read p p1; do if test -f $$p || test -f $$p1; \
then echo "$$p"; echo "$$p"; else :; fi; \
done | \
sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
-e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
sed 'N;N;N;s,\n, ,g' | \
$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
{ d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
if ($$2 == $$4) files[d] = files[d] " " $$1; \
else { print "f", $$3 "/" $$4, $$1; } } \
END { for (d in files) print "f", d, files[d] }' | \
while read type dir files; do \
if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
test -z "$$files" || { \
echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
$(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
} \
; done
uninstall-binPROGRAMS:
@$(NORMAL_UNINSTALL)
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
files=`for p in $$list; do echo "$$p"; done | \
sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
-e 's/$$/$(EXEEXT)/' `; \
test -n "$$list" || exit 0; \
echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(bindir)" && rm -f $$files
clean-binPROGRAMS:
@list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
echo " rm -f" $$list; \
rm -f $$list || exit $$?; \
test -n "$(EXEEXT)" || exit 0; \
list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
echo " rm -f" $$list; \
rm -f $$list
caldav-test$(EXEEXT): $(caldav_test_OBJECTS) $(caldav_test_DEPENDENCIES)
@rm -f caldav-test$(EXEEXT)
$(caldav_test_LINK) $(caldav_test_OBJECTS) $(caldav_test_LDADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/caldav-test.Po@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(PROGRAMS) $(HEADERS)
installdirs:
for dir in "$(DESTDIR)$(bindir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-binPROGRAMS
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-binPROGRAMS
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \
clean-generic clean-libtool ctags distclean distclean-compile \
distclean-generic distclean-libtool distclean-tags distdir dvi \
dvi-am html html-am info info-am install install-am \
install-binPROGRAMS install-data install-data-am install-dvi \
install-dvi-am install-exec install-exec-am install-html \
install-html-am install-info install-info-am install-man \
install-pdf install-pdf-am install-ps install-ps-am \
install-strip installcheck installcheck-am installdirs \
maintainer-clean maintainer-clean-generic mostlyclean \
mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
pdf pdf-am ps ps-am tags uninstall uninstall-am \
uninstall-binPROGRAMS
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

383
test/src/.svn/text-base/caldav-test.c.svn-base
Unescape View File

@ -0,0 +1,383 @@
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "caldav.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <glib.h>
#include <sys/stat.h>
#include <string.h>
#include <time.h>
gchar* make_url(gchar* uid, gchar* pwd, gchar* url) {
char* pos;
char* protocol = NULL;
char* uri = NULL;
char* newurl = NULL;
if (!uid)
return g_strdup(url);
if ((pos = strstr(url, "//")) != NULL) {
uri = g_strdup(&(*(pos + 2)));
protocol = g_strndup(url, pos + 2 - url);
}
else {
protocol = g_strdup("http://");
}
if (!pwd)
newurl = g_strdup_printf("%s%s@%s", protocol, uid, uri);
else
newurl = g_strdup_printf("%s%s:%s@%s", protocol, uid, pwd, uri);
g_free(uri);
g_free(protocol);
return newurl;
}
#define BUFFER 1000
gchar* read_stream(FILE* stream, gchar* mem) {
int len, fd;
char buf[BUFFER];
struct stat sb;
fd = fileno(stream);
fstat(fd, &sb);
while ((len = read(fd, &buf, sizeof(buf))) > 0) {
mem = (char *) realloc(mem, sizeof(buf) + 1);
strncat(mem, buf, sizeof(buf));
}
mem[sb.st_size] = '\0';
fclose(stream);
return mem;
}
time_t make_time_t(const char* time_elem) {
struct tm datetime = {0,0,0,0,0,0,0,0,0,0,NULL};
//struct tm* tmp;
gchar** elem;
time_t t;
//t = time(NULL);
//tmp = localtime(&t);
elem = g_strsplit(time_elem, "/", 3);
if (g_strv_length(elem) == 3) {
datetime.tm_year = atoi(elem[0]) - 1900;
datetime.tm_mon = atoi(elem[1]) - 1;
datetime.tm_mday = atoi(elem[2]);
t = mktime(&datetime);
}
g_strfreev(elem);
return t;
}
/* [yyyy/mm/dd[ hh/mm[/ss[/z]]] */
time_t make_fbtime_t(const char* time_elem) {
struct tm datetime = {0,0,0,0,0,0,0,0,0,0,NULL};
gboolean utc = FALSE;
gchar** elem;
gchar** dt;
time_t t;
guint length;
dt = g_strsplit(time_elem, " ", 2);
length = g_strv_length(dt);
if (length > 1) {
elem = g_strsplit(dt[1], "/", 4);
length = g_strv_length(elem);
datetime.tm_hour = atoi(elem[0]);
datetime.tm_min = atoi(elem[1]);
if (length > 2)
datetime.tm_sec = atoi(elem[2]);
if (length > 3 && strcasecmp(elem[3], "z") == 0)
utc = TRUE;
g_strfreev(elem);
}
elem = g_strsplit(time_elem, "/", 3);
datetime.tm_year = atoi(elem[0]) - 1900;
datetime.tm_mon = atoi(elem[1]) - 1;
datetime.tm_mday = atoi(elem[2]);
g_strfreev(elem);
if (utc) {
t = mktime(&datetime);
struct tm* utc_time = gmtime(&t);
t = mktime(utc_time);
//g_free(utc_time);
}
else
t = mktime(&datetime);
return t;
}
static const char* usage[] = {
"caldav-test is part of libcaldav for claws-mails "
"vcalendar plugin.\nCopyright (C) Michael Rasmussen, 2008.\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\nusage:\n\tcaldav-test [Options] URL\n"
"\n\tOptions:\n\t\t-a\taction [is-caldav|add|delete|modify|get|get-all|displayname|options|freebusy]\n"
"\t\t-c\tprovide custom cacert (path to cert)\n"
"\t\t-d\tdebug (show request/response)\n"
"\t\t-e\tend [yyyy/mm/dd]. For FREEBUSY [yyyy/mm/dd[ hh/mm[/ss[/z]]]\n"
"\t\t-f\tfile. Alternative is to use IO redirection (<)\n"
"\t\t-p\tpassword\n"
"\t\t-s\tstart [yyyy/mm/dd]. For FREEBUSY [yyyy/mm/dd[ hh/mm[/ss[/z]]]\n"
"\t\t-u\tusername\n"
"\t\t-v\tdisable certificate verification\n"
"\t\t-h|-?\tusage\n"
};
int main(int argc, char **argv) {
int c;
CALDAV_ACTION ACTION = UNKNOWN;
gboolean debug = FALSE;
gboolean verify_ssl_certificate = TRUE;
FILE* stream = NULL;
gchar* username = NULL;
gchar* password = NULL;
gchar* url = NULL;
gchar* start = NULL;
gchar* end = NULL;
response* result;
CALDAV_RESPONSE res = UNKNOWN;
gchar* input = NULL;
char** options = NULL;
runtime_info* opt;
gchar* custom_cacert = NULL;
opt = caldav_get_runtime_info();
while ((c = getopt(argc, argv, "a:c:de:f:hp:s:u:v?")) != -1) {
switch (c) {
case 'h':
case '?':
fprintf(stdout, "%s", usage[0]);
return 0;
case 'a':
if (strcmp("add", optarg) == 0) {
ACTION = ADD;
}
else if (strcmp("delete", optarg) == 0) {
ACTION = DELETE;
}
else if (strcmp("modify", optarg) == 0) {
ACTION = MODIFY;
}
else if (strcmp("get", optarg) == 0) {
ACTION = GET;
}
else if (strcmp("get-all", optarg) == 0) {
ACTION = GETALL;
}
else if (strcmp("displayname", optarg) == 0) {
ACTION = GETCALNAME;
}
else if (strcmp("is-caldav", optarg) == 0) {
ACTION = ISCALDAV;
}
else if (strcmp("options", optarg) == 0) {
ACTION = OPTIONS;
}
else if (strcmp("freebusy", optarg) == 0) {
ACTION = FREEBUSY;
}
else {
fprintf(stderr, "Unknown action: %s\n", optarg);
fprintf(stderr, "%s", usage[0]);
return 1;
}
break;
case 'c':
custom_cacert = g_strdup(optarg);
break;
case 'd':
debug = TRUE;
break;
case 'e':
end = optarg;
break;
case 'f':
stream = fopen(optarg, "r");
if (!stream) {
perror("File");
caldav_free_runtime_info(&opt);
return 1;
}
case 'p':
password = optarg;
break;
case 's':
start = optarg;
break;
case 'u':
username = optarg;
break;
case 'v':
verify_ssl_certificate = FALSE;
break;
default:
return 1;
}
}
if (optind < argc - 1) {
fprintf(stderr, "Error: Only enter one URL\n");
fprintf(stderr, "%s", usage[0]);
caldav_free_runtime_info(&opt);
return 1;
}
if (optind == argc) {
fprintf(stderr, "Error: Missing URL\n");
fprintf(stderr, "%s", usage[0]);
caldav_free_runtime_info(&opt);
return 1;
}
if (ACTION == UNKNOWN) {
fprintf(stderr, "Error: Missing action\n");
fprintf(stderr, "%s", usage[0]);
caldav_free_runtime_info(&opt);
return 1;
}
if (ACTION != GETALL && ACTION != GET && ACTION != GETCALNAME &&
ACTION != ISCALDAV && ACTION != OPTIONS && ACTION != FREEBUSY) {
struct stat sb;
if (fstat(fileno(stdin), &sb) == -1) {
if (!stream) {
perror("stat");
caldav_free_runtime_info(&opt);
return 1;
}
}
else {
if (stream && sb.st_size > 0) {
fprintf(stderr, "Error: Option -f is in use. Cannot redirect stdin\n");
caldav_free_runtime_info(&opt);
return 1;
}
else
stream = (stream) ? stream : stdin;
}
input = read_stream(stream, input);
if (!input) {
fprintf(stderr, "Error: Could not read from file\n");
caldav_free_runtime_info(&opt);
return 1;
}
}
if (ACTION == GET || ACTION == FREEBUSY) {
if (start == NULL || end == NULL) {
fprintf(stderr, "Error: Option '-a get' or '-a freebusy' requires option e and s\n");
fprintf(stderr, "%s", usage[0]);
caldav_free_runtime_info(&opt);
return 1;
}
}
url = make_url(username, password, argv[optind]);
if (debug) {
opt->options->debug = 1;
opt->options->trace_ascii = 1;
}
opt->options->verify_ssl_certificate = verify_ssl_certificate;
opt->options->custom_cacert = g_strdup(custom_cacert);
g_free(custom_cacert);
result = caldav_get_response();
switch (ACTION) {
case GETALL: res = caldav_getall_object(result, url, opt); break;
case GET: res = caldav_get_object(
result, make_time_t(start), make_time_t(end), url, opt); break;
case FREEBUSY: res = caldav_get_freebusy(
result, make_fbtime_t(start), make_fbtime_t(end), url, opt); break;
case ADD: res = caldav_add_object(input, url, opt); break;
case DELETE: res = caldav_delete_object(input, url, opt); break;
case MODIFY: res = caldav_modify_object(input, url, opt); break;
case GETCALNAME: res = caldav_get_displayname(result, url, opt); break;
case ISCALDAV:
res = caldav_enabled_resource(url, opt);
if (res)
res = OK;
else {
if (opt->error->code > 0) {
switch (opt->error->code) {
case 401:
case 403: res = FORBIDDEN; break;
case 409: res = CONFLICT; break;
case 423: res = LOCKED; break;
case 501: res = NOTIMPLEMENTED; break;
default: res = CONFLICT; break;
}
}
else
res = CONFLICT;
}
break;
case OPTIONS:
options = caldav_get_server_options(url, opt);
if (options)
res = OK;
else {
if (opt->error->code > 0) {
switch (opt->error->code) {
case 401:
case 403: res = FORBIDDEN; break;
case 409: res = CONFLICT; break;
case 423: res = LOCKED; break;
case 501: res = NOTIMPLEMENTED; break;
default: res = CONFLICT; break;
}
}
else
res = CONFLICT;
}
break;
default: break;
}
g_free(url);
g_free(input);
if (res != OK) {
fprintf(stderr, "Error\nCode: %ld\n%s\n", opt->error->code, opt->error->str);
caldav_free_runtime_info(&opt);
caldav_free_response(&result);
return 1;
}
if (result->msg && ACTION != OPTIONS) {
fprintf(stdout, "%s", result->msg);
gchar* endline = strrchr(result->msg, '\n');
if (endline) {
if (strlen(endline) != 1)
fprintf(stdout, "\n");
}
else
fprintf(stdout, "\n");
}
else if (ACTION == OPTIONS) {
char** tmp = options;
while (*options) {
fprintf(stdout, "%s\n", *options++);
}
g_strfreev(tmp);
}
else if (ACTION == GET || ACTION == GETALL || ACTION == GETCALNAME || ACTION == FREEBUSY) {
fprintf(stdout, "empty collection\n");
}
fprintf(stdout, "OK\n");
caldav_free_response(&result);
caldav_free_runtime_info(&opt);
return 0;
}

24
test/src/Makefile.am
Unescape View File

@ -0,0 +1,24 @@
AUTOMAKE_OPTIONS = gnu
if BUILD_CALDAV
INCLUDES = \
@CURL_CFLAGS@ \
@GLIB_CFLAGS@ \
-I$(top_srcdir) \
-I$(top_srcdir)/src
bin_PROGRAMS = caldav-test
caldav_test_SOURCES = \
caldav-test.c
noinst_HEADERS =
caldav_test_LDFLAGS = \
-L$(top_builddir)/src
caldav_test_LDADD = \
@CURL_LIBS@ \
@GLIB_LIBS@ \
-lcaldav
endif

568
test/src/Makefile.in
Unescape View File

@ -0,0 +1,568 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
@BUILD_CALDAV_TRUE@bin_PROGRAMS = caldav-test$(EXEEXT)
subdir = test/src
DIST_COMMON = $(noinst_HEADERS) $(srcdir)/Makefile.am \
$(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
am__installdirs = "$(DESTDIR)$(bindir)"
PROGRAMS = $(bin_PROGRAMS)
am__caldav_test_SOURCES_DIST = caldav-test.c
@BUILD_CALDAV_TRUE@am_caldav_test_OBJECTS = caldav-test.$(OBJEXT)
caldav_test_OBJECTS = $(am_caldav_test_OBJECTS)
caldav_test_DEPENDENCIES =
caldav_test_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(caldav_test_LDFLAGS) $(LDFLAGS) -o $@
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(caldav_test_SOURCES)
DIST_SOURCES = $(am__caldav_test_SOURCES_DIST)
HEADERS = $(noinst_HEADERS)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
@BUILD_CALDAV_TRUE@INCLUDES = \
@BUILD_CALDAV_TRUE@ @CURL_CFLAGS@ \
@BUILD_CALDAV_TRUE@ @GLIB_CFLAGS@ \
@BUILD_CALDAV_TRUE@ -I$(top_srcdir) \
@BUILD_CALDAV_TRUE@ -I$(top_srcdir)/src
@BUILD_CALDAV_TRUE@caldav_test_SOURCES = \
@BUILD_CALDAV_TRUE@ caldav-test.c
@BUILD_CALDAV_TRUE@noinst_HEADERS =
@BUILD_CALDAV_TRUE@caldav_test_LDFLAGS = \
@BUILD_CALDAV_TRUE@ -L$(top_builddir)/src
@BUILD_CALDAV_TRUE@caldav_test_LDADD = \
@BUILD_CALDAV_TRUE@ @CURL_LIBS@ \
@BUILD_CALDAV_TRUE@ @GLIB_LIBS@ \
@BUILD_CALDAV_TRUE@ -lcaldav
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu test/src/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu test/src/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
install-binPROGRAMS: $(bin_PROGRAMS)
@$(NORMAL_INSTALL)
test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
for p in $$list; do echo "$$p $$p"; done | \
sed 's/$(EXEEXT)$$//' | \
while read p p1; do if test -f $$p || test -f $$p1; \
then echo "$$p"; echo "$$p"; else :; fi; \
done | \
sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
-e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
sed 'N;N;N;s,\n, ,g' | \
$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
{ d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
if ($$2 == $$4) files[d] = files[d] " " $$1; \
else { print "f", $$3 "/" $$4, $$1; } } \
END { for (d in files) print "f", d, files[d] }' | \
while read type dir files; do \
if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
test -z "$$files" || { \
echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
$(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
} \
; done
uninstall-binPROGRAMS:
@$(NORMAL_UNINSTALL)
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
files=`for p in $$list; do echo "$$p"; done | \
sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
-e 's/$$/$(EXEEXT)/' `; \
test -n "$$list" || exit 0; \
echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(bindir)" && rm -f $$files
clean-binPROGRAMS:
@list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
echo " rm -f" $$list; \
rm -f $$list || exit $$?; \
test -n "$(EXEEXT)" || exit 0; \
list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
echo " rm -f" $$list; \
rm -f $$list
caldav-test$(EXEEXT): $(caldav_test_OBJECTS) $(caldav_test_DEPENDENCIES)
@rm -f caldav-test$(EXEEXT)
$(caldav_test_LINK) $(caldav_test_OBJECTS) $(caldav_test_LDADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/caldav-test.Po@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(PROGRAMS) $(HEADERS)
installdirs:
for dir in "$(DESTDIR)$(bindir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-binPROGRAMS
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-binPROGRAMS
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \
clean-generic clean-libtool ctags distclean distclean-compile \
distclean-generic distclean-libtool distclean-tags distdir dvi \
dvi-am html html-am info info-am install install-am \
install-binPROGRAMS install-data install-data-am install-dvi \
install-dvi-am install-exec install-exec-am install-html \
install-html-am install-info install-info-am install-man \
install-pdf install-pdf-am install-ps install-ps-am \
install-strip installcheck installcheck-am installdirs \
maintainer-clean maintainer-clean-generic mostlyclean \
mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
pdf pdf-am ps ps-am tags uninstall uninstall-am \
uninstall-binPROGRAMS
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

383
test/src/caldav-test.c
Unescape View File

@ -0,0 +1,383 @@
/* Copyright (c) 2008 Michael Rasmussen (mir@datanom.net)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "caldav.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <glib.h>
#include <sys/stat.h>
#include <string.h>
#include <time.h>
gchar* make_url(gchar* uid, gchar* pwd, gchar* url) {
char* pos;
char* protocol = NULL;
char* uri = NULL;
char* newurl = NULL;
if (!uid)
return g_strdup(url);
if ((pos = strstr(url, "//")) != NULL) {
uri = g_strdup(&(*(pos + 2)));
protocol = g_strndup(url, pos + 2 - url);
}
else {
protocol = g_strdup("http://");
}
if (!pwd)
newurl = g_strdup_printf("%s%s@%s", protocol, uid, uri);
else
newurl = g_strdup_printf("%s%s:%s@%s", protocol, uid, pwd, uri);
g_free(uri);
g_free(protocol);
return newurl;
}
#define BUFFER 1000
gchar* read_stream(FILE* stream, gchar* mem) {
int len, fd;
char buf[BUFFER];
struct stat sb;
fd = fileno(stream);
fstat(fd, &sb);
while ((len = read(fd, &buf, sizeof(buf))) > 0) {
mem = (char *) realloc(mem, sizeof(buf) + 1);
strncat(mem, buf, sizeof(buf));
}
mem[sb.st_size] = '\0';
fclose(stream);
return mem;
}
time_t make_time_t(const char* time_elem) {
struct tm datetime = {0,0,0,0,0,0,0,0,0,0,NULL};
//struct tm* tmp;
gchar** elem;
time_t t;
//t = time(NULL);
//tmp = localtime(&t);
elem = g_strsplit(time_elem, "/", 3);
if (g_strv_length(elem) == 3) {
datetime.tm_year = atoi(elem[0]) - 1900;
datetime.tm_mon = atoi(elem[1]) - 1;
datetime.tm_mday = atoi(elem[2]);
t = mktime(&datetime);
}
g_strfreev(elem);
return t;
}
/* [yyyy/mm/dd[ hh/mm[/ss[/z]]] */
time_t make_fbtime_t(const char* time_elem) {
struct tm datetime = {0,0,0,0,0,0,0,0,0,0,NULL};
gboolean utc = FALSE;
gchar** elem;
gchar** dt;
time_t t;
guint length;
dt = g_strsplit(time_elem, " ", 2);
length = g_strv_length(dt);
if (length > 1) {
elem = g_strsplit(dt[1], "/", 4);
length = g_strv_length(elem);
datetime.tm_hour = atoi(elem[0]);
datetime.tm_min = atoi(elem[1]);
if (length > 2)
datetime.tm_sec = atoi(elem[2]);
if (length > 3 && strcasecmp(elem[3], "z") == 0)
utc = TRUE;
g_strfreev(elem);
}
elem = g_strsplit(time_elem, "/", 3);
datetime.tm_year = atoi(elem[0]) - 1900;
datetime.tm_mon = atoi(elem[1]) - 1;
datetime.tm_mday = atoi(elem[2]);
g_strfreev(elem);
if (utc) {
t = mktime(&datetime);
struct tm* utc_time = gmtime(&t);
t = mktime(utc_time);
//g_free(utc_time);
}
else
t = mktime(&datetime);
return t;
}
static const char* usage[] = {
"caldav-test is part of libcaldav for claws-mails "
"vcalendar plugin.\nCopyright (C) Michael Rasmussen, 2008.\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\nusage:\n\tcaldav-test [Options] URL\n"
"\n\tOptions:\n\t\t-a\taction [is-caldav|add|delete|modify|get|get-all|displayname|options|freebusy]\n"
"\t\t-c\tprovide custom cacert (path to cert)\n"
"\t\t-d\tdebug (show request/response)\n"
"\t\t-e\tend [yyyy/mm/dd]. For FREEBUSY [yyyy/mm/dd[ hh/mm[/ss[/z]]]\n"
"\t\t-f\tfile. Alternative is to use IO redirection (<)\n"
"\t\t-p\tpassword\n"
"\t\t-s\tstart [yyyy/mm/dd]. For FREEBUSY [yyyy/mm/dd[ hh/mm[/ss[/z]]]\n"
"\t\t-u\tusername\n"
"\t\t-v\tdisable certificate verification\n"
"\t\t-h|-?\tusage\n"
};
int main(int argc, char **argv) {
int c;
CALDAV_ACTION ACTION = UNKNOWN;
gboolean debug = FALSE;
gboolean verify_ssl_certificate = TRUE;
FILE* stream = NULL;
gchar* username = NULL;
gchar* password = NULL;
gchar* url = NULL;
gchar* start = NULL;
gchar* end = NULL;
response* result;
CALDAV_RESPONSE res = UNKNOWN;
gchar* input = NULL;
char** options = NULL;
runtime_info* opt;
gchar* custom_cacert = NULL;
opt = caldav_get_runtime_info();
while ((c = getopt(argc, argv, "a:c:de:f:hp:s:u:v?")) != -1) {
switch (c) {
case 'h':
case '?':
fprintf(stdout, "%s", usage[0]);
return 0;
case 'a':
if (strcmp("add", optarg) == 0) {
ACTION = ADD;
}
else if (strcmp("delete", optarg) == 0) {
ACTION = DELETE;
}
else if (strcmp("modify", optarg) == 0) {
ACTION = MODIFY;
}
else if (strcmp("get", optarg) == 0) {
ACTION = GET;
}
else if (strcmp("get-all", optarg) == 0) {
ACTION = GETALL;
}
else if (strcmp("displayname", optarg) == 0) {
ACTION = GETCALNAME;
}
else if (strcmp("is-caldav", optarg) == 0) {
ACTION = ISCALDAV;
}
else if (strcmp("options", optarg) == 0) {
ACTION = OPTIONS;
}
else if (strcmp("freebusy", optarg) == 0) {
ACTION = FREEBUSY;
}
else {
fprintf(stderr, "Unknown action: %s\n", optarg);
fprintf(stderr, "%s", usage[0]);
return 1;
}
break;
case 'c':
custom_cacert = g_strdup(optarg);
break;
case 'd':
debug = TRUE;
break;
case 'e':
end = optarg;
break;
case 'f':
stream = fopen(optarg, "r");
if (!stream) {
perror("File");
caldav_free_runtime_info(&opt);
return 1;
}
case 'p':
password = optarg;
break;
case 's':
start = optarg;
break;
case 'u':
username = optarg;
break;
case 'v':
verify_ssl_certificate = FALSE;
break;
default:
return 1;
}
}
if (optind < argc - 1) {
fprintf(stderr, "Error: Only enter one URL\n");
fprintf(stderr, "%s", usage[0]);
caldav_free_runtime_info(&opt);
return 1;
}
if (optind == argc) {
fprintf(stderr, "Error: Missing URL\n");
fprintf(stderr, "%s", usage[0]);
caldav_free_runtime_info(&opt);
return 1;
}
if (ACTION == UNKNOWN) {
fprintf(stderr, "Error: Missing action\n");
fprintf(stderr, "%s", usage[0]);
caldav_free_runtime_info(&opt);
return 1;
}
if (ACTION != GETALL && ACTION != GET && ACTION != GETCALNAME &&
ACTION != ISCALDAV && ACTION != OPTIONS && ACTION != FREEBUSY) {
struct stat sb;
if (fstat(fileno(stdin), &sb) == -1) {
if (!stream) {
perror("stat");
caldav_free_runtime_info(&opt);
return 1;
}
}
else {
if (stream && sb.st_size > 0) {
fprintf(stderr, "Error: Option -f is in use. Cannot redirect stdin\n");
caldav_free_runtime_info(&opt);
return 1;
}
else
stream = (stream) ? stream : stdin;
}
input = read_stream(stream, input);
if (!input) {
fprintf(stderr, "Error: Could not read from file\n");
caldav_free_runtime_info(&opt);
return 1;
}
}
if (ACTION == GET || ACTION == FREEBUSY) {
if (start == NULL || end == NULL) {
fprintf(stderr, "Error: Option '-a get' or '-a freebusy' requires option e and s\n");
fprintf(stderr, "%s", usage[0]);
caldav_free_runtime_info(&opt);
return 1;
}
}
url = make_url(username, password, argv[optind]);
if (debug) {
opt->options->debug = 1;
opt->options->trace_ascii = 1;
}
opt->options->verify_ssl_certificate = verify_ssl_certificate;
opt->options->custom_cacert = g_strdup(custom_cacert);
g_free(custom_cacert);
result = caldav_get_response();
switch (ACTION) {
case GETALL: res = caldav_getall_object(result, url, opt); break;
case GET: res = caldav_get_object(
result, make_time_t(start), make_time_t(end), url, opt); break;
case FREEBUSY: res = caldav_get_freebusy(
result, make_fbtime_t(start), make_fbtime_t(end), url, opt); break;
case ADD: res = caldav_add_object(input, url, opt); break;
case DELETE: res = caldav_delete_object(input, url, opt); break;
case MODIFY: res = caldav_modify_object(input, url, opt); break;
case GETCALNAME: res = caldav_get_displayname(result, url, opt); break;
case ISCALDAV:
res = caldav_enabled_resource(url, opt);
if (res)
res = OK;
else {
if (opt->error->code > 0) {
switch (opt->error->code) {
case 401:
case 403: res = FORBIDDEN; break;
case 409: res = CONFLICT; break;
case 423: res = LOCKED; break;
case 501: res = NOTIMPLEMENTED; break;
default: res = CONFLICT; break;
}
}
else
res = CONFLICT;
}
break;
case OPTIONS:
options = caldav_get_server_options(url, opt);
if (options)
res = OK;
else {
if (opt->error->code > 0) {
switch (opt->error->code) {
case 401:
case 403: res = FORBIDDEN; break;
case 409: res = CONFLICT; break;
case 423: res = LOCKED; break;
case 501: res = NOTIMPLEMENTED; break;
default: res = CONFLICT; break;
}
}
else
res = CONFLICT;
}
break;
default: break;
}
g_free(url);
g_free(input);
if (res != OK) {
fprintf(stderr, "Error\nCode: %ld\n%s\n", opt->error->code, opt->error->str);
caldav_free_runtime_info(&opt);
caldav_free_response(&result);
return 1;
}
if (result->msg && ACTION != OPTIONS) {
fprintf(stdout, "%s", result->msg);
gchar* endline = strrchr(result->msg, '\n');
if (endline) {
if (strlen(endline) != 1)
fprintf(stdout, "\n");
}
else
fprintf(stdout, "\n");
}
else if (ACTION == OPTIONS) {
char** tmp = options;
while (*options) {
fprintf(stdout, "%s\n", *options++);
}
g_strfreev(tmp);
}
else if (ACTION == GET || ACTION == GETALL || ACTION == GETCALNAME || ACTION == FREEBUSY) {
fprintf(stdout, "empty collection\n");
}
fprintf(stdout, "OK\n");
caldav_free_response(&result);
caldav_free_runtime_info(&opt);
return 0;
}

23
test/unittest/.svn/all-wcprops
Unescape View File

@ -0,0 +1,23 @@
K 25
svn:wc:ra_dav:version-url
V 50
/svnroot/libcaldav/!svn/ver/42/trunk/test/unittest
END
Makefile.in
K 25
svn:wc:ra_dav:version-url
V 62
/svnroot/libcaldav/!svn/ver/42/trunk/test/unittest/Makefile.in
END
libunit.c
K 25
svn:wc:ra_dav:version-url
V 60
/svnroot/libcaldav/!svn/ver/40/trunk/test/unittest/libunit.c
END
Makefile.am
K 25
svn:wc:ra_dav:version-url
V 62
/svnroot/libcaldav/!svn/ver/30/trunk/test/unittest/Makefile.am
END

130
test/unittest/.svn/entries
Unescape View File

@ -0,0 +1,130 @@
10
dir
42
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav/trunk/test/unittest
https://libcaldav.svn.sourceforge.net/svnroot/libcaldav
2010-05-29T15:45:56.236020Z
42
miras
6bb92309-7149-0410-b568-bc30dfd0a1d5
Makefile.in
file
2010-05-31T07:07:58.000000Z
b1273950d94bccb8c4248fdd8c4b7a89
2010-05-29T15:45:56.236020Z
42
miras
has-props
17653
libunit.c
file
2010-05-31T07:07:58.000000Z
6d177ca8a47a1b2aa5d05b3aa65f9df5
2010-05-23T21:46:08.944313Z
40
miras
has-props
16563
Makefile.am
file
2010-05-31T07:07:58.000000Z
60502f8e62676b65dc3e97abff162887
2010-04-04T20:17:57.156621Z
30
miras
has-props
337

5
test/unittest/.svn/prop-base/Makefile.am.svn-base
Unescape View File

@ -0,0 +1,5 @@
K 12
svn:keywords
V 22
Author Date Id Rev URL
END

5
test/unittest/.svn/prop-base/Makefile.in.svn-base
Unescape View File

@ -0,0 +1,5 @@
K 12
svn:keywords
V 22
Author Date Id Rev URL
END

9
test/unittest/.svn/prop-base/libunit.c.svn-base
Unescape View File

@ -0,0 +1,9 @@
K 13
svn:eol-style
V 6
native
K 12
svn:keywords
V 22
Author Date Id Rev URL
END

22
test/unittest/.svn/text-base/Makefile.am.svn-base
Unescape View File

@ -0,0 +1,22 @@
AUTOMAKE_OPTIONS = gnu
if BUILD_UNITTEST
INCLUDES = \
@CURL_CFLAGS@ \
@GLIB_CFLAGS@ \
-I$(top_srcdir) \
-I$(top_srcdir)/src
bin_PROGRAMS = unittest
unittest_SOURCES = \
libunit.c
unittest_LDFLAGS = \
-L$(top_builddir)/src
unittest_LDADD = \
@CURL_LIBS@ \
@GLIB_LIBS@ \
-lcaldav
endif

564
test/unittest/.svn/text-base/Makefile.in.svn-base
Unescape View File

@ -0,0 +1,564 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
@BUILD_UNITTEST_TRUE@bin_PROGRAMS = unittest$(EXEEXT)
subdir = test/unittest
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
am__installdirs = "$(DESTDIR)$(bindir)"
PROGRAMS = $(bin_PROGRAMS)
am__unittest_SOURCES_DIST = libunit.c
@BUILD_UNITTEST_TRUE@am_unittest_OBJECTS = libunit.$(OBJEXT)
unittest_OBJECTS = $(am_unittest_OBJECTS)
unittest_DEPENDENCIES =
unittest_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(unittest_LDFLAGS) \
$(LDFLAGS) -o $@
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(unittest_SOURCES)
DIST_SOURCES = $(am__unittest_SOURCES_DIST)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
@BUILD_UNITTEST_TRUE@INCLUDES = \
@BUILD_UNITTEST_TRUE@ @CURL_CFLAGS@ \
@BUILD_UNITTEST_TRUE@ @GLIB_CFLAGS@ \
@BUILD_UNITTEST_TRUE@ -I$(top_srcdir) \
@BUILD_UNITTEST_TRUE@ -I$(top_srcdir)/src
@BUILD_UNITTEST_TRUE@unittest_SOURCES = \
@BUILD_UNITTEST_TRUE@ libunit.c
@BUILD_UNITTEST_TRUE@unittest_LDFLAGS = \
@BUILD_UNITTEST_TRUE@ -L$(top_builddir)/src
@BUILD_UNITTEST_TRUE@unittest_LDADD = \
@BUILD_UNITTEST_TRUE@ @CURL_LIBS@ \
@BUILD_UNITTEST_TRUE@ @GLIB_LIBS@ \
@BUILD_UNITTEST_TRUE@ -lcaldav
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu test/unittest/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu test/unittest/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
install-binPROGRAMS: $(bin_PROGRAMS)
@$(NORMAL_INSTALL)
test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
for p in $$list; do echo "$$p $$p"; done | \
sed 's/$(EXEEXT)$$//' | \
while read p p1; do if test -f $$p || test -f $$p1; \
then echo "$$p"; echo "$$p"; else :; fi; \
done | \
sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
-e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
sed 'N;N;N;s,\n, ,g' | \
$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
{ d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
if ($$2 == $$4) files[d] = files[d] " " $$1; \
else { print "f", $$3 "/" $$4, $$1; } } \
END { for (d in files) print "f", d, files[d] }' | \
while read type dir files; do \
if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
test -z "$$files" || { \
echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
$(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
} \
; done
uninstall-binPROGRAMS:
@$(NORMAL_UNINSTALL)
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
files=`for p in $$list; do echo "$$p"; done | \
sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
-e 's/$$/$(EXEEXT)/' `; \
test -n "$$list" || exit 0; \
echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(bindir)" && rm -f $$files
clean-binPROGRAMS:
@list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
echo " rm -f" $$list; \
rm -f $$list || exit $$?; \
test -n "$(EXEEXT)" || exit 0; \
list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
echo " rm -f" $$list; \
rm -f $$list
unittest$(EXEEXT): $(unittest_OBJECTS) $(unittest_DEPENDENCIES)
@rm -f unittest$(EXEEXT)
$(unittest_LINK) $(unittest_OBJECTS) $(unittest_LDADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libunit.Po@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(PROGRAMS)
installdirs:
for dir in "$(DESTDIR)$(bindir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-binPROGRAMS
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-binPROGRAMS
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \
clean-generic clean-libtool ctags distclean distclean-compile \
distclean-generic distclean-libtool distclean-tags distdir dvi \
dvi-am html html-am info info-am install install-am \
install-binPROGRAMS install-data install-data-am install-dvi \
install-dvi-am install-exec install-exec-am install-html \
install-html-am install-info install-info-am install-man \
install-pdf install-pdf-am install-ps install-ps-am \
install-strip installcheck installcheck-am installdirs \
maintainer-clean maintainer-clean-generic mostlyclean \
mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
pdf pdf-am ps ps-am tags uninstall uninstall-am \
uninstall-binPROGRAMS
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

615
test/unittest/.svn/text-base/libunit.c.svn-base
Unescape View File

@ -0,0 +1,615 @@
/* vim: set textwidth=80 tabstop=4: */
/*
// libunit.c
//
// Copyright 2010 Michael Rasmussen <mir@datanom.net>
//
// 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, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
// MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "caldav.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <glib.h>
#include <string.h>
#include <sys/time.h>
#include <string.h>
static const char* usage[] = {
"unittest is part of libcaldav for claws-mails "
"vcalendar plugin.\nCopyright (C) Michael Rasmussen, 2008.\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\nusage:\n\tunittest [Options]\n"
"\n\tOptions:\n"
"\t\t-h|-?\tusage\n"
"\t\t-a\tURL\n"
"\t\t-d\tEnable debug\n"
"\t\t-l\tDebug library\n"
"\t\t-p\tpassword\n"
"\t\t-u\tusername\n"
};
/*
* Options can be given in one of three ways:
* 1) Entered as options on the command line
* 2) Stored in environment variables:
* - LIBCALDAV_UID -> username to use when connection to server
* - LIBCALDAV_PWD -> password, if any, to use when connection to server
* - LIBCALDAV_URL -> complete URL to server. prefixed with either
* http:// or https://
* 3) Stored in a file found in the same directory as the program:
* [server]
* password=Big secret
* username=username
* url=http[s]://bar.tld/foo
*/
#define CONFFILE "caldav-unit-settings.conf"
typedef struct {
gchar* uid;
gchar* pwd;
gchar* url;
} settings;
typedef enum {
PWD,
UID,
URL
} CONFIG;
static settings* SETTING = NULL;
gboolean DEBUG = FALSE;
gboolean DEBUG_LIB = FALSE;
void settings_free(settings** setting) {
settings* s;
if (! *setting)
return;
s = *setting;
g_free(s->url);
g_free(s->uid);
g_free(s->pwd);
g_free(s);
*setting = s = NULL;
}
settings* parse_cmdline(int argc, char** argv) {
char c;
settings* setting;
setting = g_new0(settings, 1);
while ((c = getopt(argc, argv, "ha:dlp:u:?")) != -1) {
switch (c) {
case 'h':
case '?':
fprintf(stdout, "%s", usage[0]);
return 0;
case 'a':
setting->url = g_strdup(optarg);
break;
case 'd':
DEBUG = TRUE;
break;
case 'l':
DEBUG_LIB = TRUE;
break;
case 'p':
setting->pwd = g_strdup(optarg);
break;
case 'u':
setting->uid = g_strdup(optarg);
break;
}
}
if (argv[optind]) {
fprintf(stderr, "No arguments after options expected\n");
fprintf(stderr, "%s", usage[0]);
settings_free(&setting);
return NULL;
}
return setting;
}
void read_file(const gchar* file) {
GKeyFile* keyfile;
if (! SETTING) {
SETTING = g_new0(settings, 1);
keyfile = g_key_file_new();
if (g_key_file_load_from_file(keyfile,
file,
G_KEY_FILE_KEEP_COMMENTS,
NULL)) {
SETTING->pwd = g_key_file_get_string(keyfile,
"server",
"password",
NULL);
SETTING->uid = g_key_file_get_string(keyfile,
"server",
"username",
NULL);
SETTING->url = g_key_file_get_string(keyfile,
"server",
"url",
NULL);
}
g_key_file_free(keyfile);
}
}
const gchar* get_setting_from_file(CONFIG config) {
gchar* cwd;
gchar* path;
gchar* pos;
gchar* setting = NULL;
int step;
gchar* filename = g_get_prgname();
if (filename[0] == '/') {
/* absolute path */
cwd = g_path_get_dirname(filename);
}
else if ((pos = strchr(filename, '/')) != NULL) {
/* relative path */
if (filename[0] == '.') {
char* tmp = pos;
while (tmp) {
if (strncmp(tmp, "..", 2) == 0)
step = 2;
else
step = 1;
tmp = strchr(pos + step, '/');
if (tmp)
pos = tmp;
}
if (pos == NULL) {
pos = strchr(filename, '/');
}
}
path = g_get_current_dir();
cwd = g_build_filename(path, pos + 1, NULL);
g_free(path);
if (g_file_test(cwd, G_FILE_TEST_IS_REGULAR)) {
pos = strrchr(cwd, '/');
if (pos) {
path = g_strndup(cwd, pos - cwd);
g_free(cwd);
cwd = g_strdup(path);
g_free(path);
}
}
}
else {
/* find cwd in PATH */
cwd = g_find_program_in_path(filename);
}
path = g_build_filename(cwd, CONFFILE, NULL);
g_free(cwd);
if (g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
read_file(path);
switch (config) {
case UID: setting = SETTING->uid; break;
case PWD: setting = SETTING->pwd; break;
case URL: setting = SETTING->url; break;
}
}
g_free(path);
return setting;
}
gboolean find_missing(settings** setting) {
settings* s = *setting;
const char* env;
gboolean error = FALSE;
if (! s)
return TRUE;
if (! s->uid) {
if ((env = getenv("LIBCALDAV_UID")) == NULL) {
env = get_setting_from_file(UID);
if (env == NULL)
error = TRUE;
}
s->uid = g_strdup(env);
}
if (! s->pwd) {
if ((env = getenv("LIBCALDAV_PWD")) == NULL) {
env = get_setting_from_file(PWD);
if (env == NULL)
error = TRUE;
}
s->pwd = g_strdup(env);
}
if (! s->url) {
if ((env = getenv("LIBCALDAV_URL")) == NULL) {
env = get_setting_from_file(URL);
if (env == NULL)
error = TRUE;
}
s->url = g_strdup(env);
}
settings_free(&SETTING);
return error;
}
time_t make_time_t(const char* time_elem) {
struct tm datetime = {0,0,0,0,0,0,0,0,0,0,NULL};
struct tm* tmp;
gchar** elem;
time_t t;
t = time(NULL);
tmp = localtime(&t);
elem = g_strsplit(time_elem, "/", 3);
datetime.tm_year = atoi(elem[0]) - 1900;
datetime.tm_mon = atoi(elem[1]) - 1;
datetime.tm_mday = atoi(elem[2]);
g_strfreev(elem);
t = mktime(&datetime);
return t;
}
gboolean compare_freebusy(const gchar* s1, const gchar* s2) {
const char* TOKEN = "FREEBUSY:";
gchar* pos1;
gchar* pos2;
gchar* id1;
if (! s1 && ! s2)
return TRUE;
if (! s1 || ! s2)
return FALSE;
pos1 = strstr(s2, TOKEN);
if (! pos1)
return FALSE;
pos1 += strlen(TOKEN);
pos2 = strchr(pos1, '\n');
if (! pos2)
return FALSE;
if (*(pos2 - 1) == '\r')
pos2--;
id1 = g_strndup(pos1, pos2 - pos1);
int res = strcmp(s1, id1);
g_free(id1);
return (res == 0);
}
gboolean compare_object(const gchar* TOKEN, const gchar* s1, const gchar* s2) {
gchar* pos1;
gchar* pos2;
gchar* id1;
gchar* id2;
if (! s1 && ! s2)
return TRUE;
if (! s1 || ! s2)
return FALSE;
pos1 = strstr(s1, TOKEN);
if (! pos1)
return FALSE;
pos1 += strlen(TOKEN) + 1;
pos2 = strchr(pos1, '\n');
if (! pos2)
return FALSE;
if (*(pos2 - 1) == '\r')
pos2--;
id1 = g_strndup(pos1, pos2 - pos1);
pos2 = strstr(s2, TOKEN);
if (! pos2) {
g_free(id1);
return FALSE;
}
pos2 += strlen(TOKEN) + 1;
pos1 = strchr(pos2, '\n');
if (! pos1) {
g_free(id1);
return FALSE;
}
if (*(pos1 - 1) == '\r')
pos1--;
id2 = g_strndup(pos2, pos1 - pos2);
int res = strcmp(id1, id2);
g_free(id1);
g_free(id2);
return (res == 0);
}
void run_tests(settings* s) {
runtime_info* info = caldav_get_runtime_info();
response* resp = caldav_get_response();
gchar** parts;
gchar* url;
gchar* object;
if (DEBUG_LIB) {
info->options->debug = 1;
info->options->trace_ascii = 1;
}
parts = g_strsplit(s->url, "//", 2);
url = g_strconcat(
parts[0], "//", s->uid, ":", s->pwd, "@", parts[1], NULL);
g_strfreev(parts);
fprintf(stdout, "Test caldav_enabled_resource:\t\t\t");
if (caldav_enabled_resource(url, info)) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "caldav enabled server\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test caldav_get_displayname:\t\t\t");
if (caldav_get_displayname(resp, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Display Name: %s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
fprintf(stdout, "Test caldav_get_server_options:\t\t\t");
if ((parts = caldav_get_server_options(url, info)) != NULL) {
fprintf(stdout, "OK\n");
if (DEBUG) {
char** tmp = parts;
while (*tmp) {
fprintf(stdout, "--> %s\n", *tmp++);
}
}
g_strfreev(parts);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_file_get_contents("../ics/add.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_add_object:\t\t\t\t");
if (caldav_add_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Added successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was added:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/15"),
make_time_t("2008/04/16"), url, info) == OK) {
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
g_free(object);
fprintf(stdout, "Test FREEBUSY search the same day:\t\t");
if (caldav_get_freebusy(resp, make_time_t("2008/04/15"),
make_time_t("2008/04/16"), url, info) == OK) {
if (compare_freebusy("20080415T151500Z/20080415T162500", resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
g_file_get_contents("../ics/modify.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_modify_object:\t\t\t");
if (caldav_modify_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Modified successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was modified:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/16"),
make_time_t("2008/04/17"), url, info) == OK) {
if (compare_object("DTEND", object, resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
fprintf(stdout, "Test caldav_getall_object:\t\t\t");
if (caldav_getall_object(resp, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object exists:\t\t\t\t");
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "FAIL\n");
else
fprintf(stdout, "OK\n");
g_free(resp->msg);
resp->msg = NULL;
g_free(object);
g_file_get_contents("../ics/delete.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_delete_object:\t\t\t");
if (caldav_delete_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Deleted successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was deleted:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/16"),
make_time_t("2008/04/17"), url, info) == OK) {
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "FAIL\n");
else
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "%s\n", (resp->msg) ? resp->msg : "No object found");
g_free(resp->msg);
resp->msg = NULL;
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(object);
fprintf(stdout, "\nTesting without using locks\n");
info->options->use_locking = 0;
g_file_get_contents("../ics/add.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_add_object:\t\t\t\t");
if (caldav_add_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Added successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was added:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/15"),
make_time_t("2008/04/16"), url, info) == OK) {
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
g_free(object);
/* fprintf(stdout, "Test FREEBUSY search the same day:\t\t");
if (caldav_get_freebusy(resp, make_time_t("2008/04/15"),
make_time_t("2008/04/16"), url, info) == OK) {
if (compare_freebusy("20080415T151500Z/20080415T162500", resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;*/
g_file_get_contents("../ics/modify.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_modify_object:\t\t\t");
if (caldav_modify_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Modified successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was modified:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/16"),
make_time_t("2008/04/17"), url, info) == OK) {
if (compare_object("DTEND", object, resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
g_free(object);
g_file_get_contents("../ics/delete.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_delete_object:\t\t\t");
if (caldav_delete_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Deleted successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was deleted:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/16"),
make_time_t("2008/04/17"), url, info) == OK) {
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "FAIL\n");
else
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "%s\n", (resp->msg) ? resp->msg : "No object found");
g_free(resp->msg);
resp->msg = NULL;
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(url);
caldav_free_response(&resp);
caldav_free_runtime_info(&info);
}
int main(int argc, char** argv) {
settings* setting;
g_set_prgname(argv[0]);
setting = parse_cmdline(argc, argv);
if (find_missing(&setting)) {
fprintf(stderr, "missing required information\n");
fprintf(stdout, "%s", usage[0]);
settings_free(&setting);
return 1;
}
run_tests(setting);
settings_free(&setting);
return 0;
}

22
test/unittest/Makefile.am
Unescape View File

@ -0,0 +1,22 @@
AUTOMAKE_OPTIONS = gnu
if BUILD_UNITTEST
INCLUDES = \
@CURL_CFLAGS@ \
@GLIB_CFLAGS@ \
-I$(top_srcdir) \
-I$(top_srcdir)/src
bin_PROGRAMS = unittest
unittest_SOURCES = \
libunit.c
unittest_LDFLAGS = \
-L$(top_builddir)/src
unittest_LDADD = \
@CURL_LIBS@ \
@GLIB_LIBS@ \
-lcaldav
endif

564
test/unittest/Makefile.in
Unescape View File

@ -0,0 +1,564 @@
# Makefile.in generated by automake 1.11.1 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
# Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
@BUILD_UNITTEST_TRUE@bin_PROGRAMS = unittest$(EXEEXT)
subdir = test/unittest
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_prog_doxygen.m4 \
$(top_srcdir)/m4/libtool.m4 $(top_srcdir)/m4/ltoptions.m4 \
$(top_srcdir)/m4/ltsugar.m4 $(top_srcdir)/m4/ltversion.m4 \
$(top_srcdir)/m4/lt~obsolete.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
CONFIG_CLEAN_VPATH_FILES =
am__installdirs = "$(DESTDIR)$(bindir)"
PROGRAMS = $(bin_PROGRAMS)
am__unittest_SOURCES_DIST = libunit.c
@BUILD_UNITTEST_TRUE@am_unittest_OBJECTS = libunit.$(OBJEXT)
unittest_OBJECTS = $(am_unittest_OBJECTS)
unittest_DEPENDENCIES =
unittest_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(unittest_LDFLAGS) \
$(LDFLAGS) -o $@
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(unittest_SOURCES)
DIST_SOURCES = $(am__unittest_SOURCES_DIST)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOXYGEN_PAPER_SIZE = @DOXYGEN_PAPER_SIZE@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
DX_CONFIG = @DX_CONFIG@
DX_DOCDIR = @DX_DOCDIR@
DX_DOT = @DX_DOT@
DX_DOXYGEN = @DX_DOXYGEN@
DX_DVIPS = @DX_DVIPS@
DX_EGREP = @DX_EGREP@
DX_ENV = @DX_ENV@
DX_FLAG_chi = @DX_FLAG_chi@
DX_FLAG_chm = @DX_FLAG_chm@
DX_FLAG_doc = @DX_FLAG_doc@
DX_FLAG_dot = @DX_FLAG_dot@
DX_FLAG_html = @DX_FLAG_html@
DX_FLAG_man = @DX_FLAG_man@
DX_FLAG_pdf = @DX_FLAG_pdf@
DX_FLAG_ps = @DX_FLAG_ps@
DX_FLAG_rtf = @DX_FLAG_rtf@
DX_FLAG_xml = @DX_FLAG_xml@
DX_HHC = @DX_HHC@
DX_LATEX = @DX_LATEX@
DX_MAKEINDEX = @DX_MAKEINDEX@
DX_PDFLATEX = @DX_PDFLATEX@
DX_PERL = @DX_PERL@
DX_PROJECT = @DX_PROJECT@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_LIBS = @GLIB_LIBS@
GREP = @GREP@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIBVERSION = @LIBVERSION@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AUTOMAKE_OPTIONS = gnu
@BUILD_UNITTEST_TRUE@INCLUDES = \
@BUILD_UNITTEST_TRUE@ @CURL_CFLAGS@ \
@BUILD_UNITTEST_TRUE@ @GLIB_CFLAGS@ \
@BUILD_UNITTEST_TRUE@ -I$(top_srcdir) \
@BUILD_UNITTEST_TRUE@ -I$(top_srcdir)/src
@BUILD_UNITTEST_TRUE@unittest_SOURCES = \
@BUILD_UNITTEST_TRUE@ libunit.c
@BUILD_UNITTEST_TRUE@unittest_LDFLAGS = \
@BUILD_UNITTEST_TRUE@ -L$(top_builddir)/src
@BUILD_UNITTEST_TRUE@unittest_LDADD = \
@BUILD_UNITTEST_TRUE@ @CURL_LIBS@ \
@BUILD_UNITTEST_TRUE@ @GLIB_LIBS@ \
@BUILD_UNITTEST_TRUE@ -lcaldav
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu test/unittest/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --gnu test/unittest/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
install-binPROGRAMS: $(bin_PROGRAMS)
@$(NORMAL_INSTALL)
test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
for p in $$list; do echo "$$p $$p"; done | \
sed 's/$(EXEEXT)$$//' | \
while read p p1; do if test -f $$p || test -f $$p1; \
then echo "$$p"; echo "$$p"; else :; fi; \
done | \
sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
-e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
sed 'N;N;N;s,\n, ,g' | \
$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
{ d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
if ($$2 == $$4) files[d] = files[d] " " $$1; \
else { print "f", $$3 "/" $$4, $$1; } } \
END { for (d in files) print "f", d, files[d] }' | \
while read type dir files; do \
if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
test -z "$$files" || { \
echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
$(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
} \
; done
uninstall-binPROGRAMS:
@$(NORMAL_UNINSTALL)
@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
files=`for p in $$list; do echo "$$p"; done | \
sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
-e 's/$$/$(EXEEXT)/' `; \
test -n "$$list" || exit 0; \
echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
cd "$(DESTDIR)$(bindir)" && rm -f $$files
clean-binPROGRAMS:
@list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
echo " rm -f" $$list; \
rm -f $$list || exit $$?; \
test -n "$(EXEEXT)" || exit 0; \
list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
echo " rm -f" $$list; \
rm -f $$list
unittest$(EXEEXT): $(unittest_OBJECTS) $(unittest_DEPENDENCIES)
@rm -f unittest$(EXEEXT)
$(unittest_LINK) $(unittest_OBJECTS) $(unittest_LDADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libunit.Po@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(PROGRAMS)
installdirs:
for dir in "$(DESTDIR)$(bindir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am: install-binPROGRAMS
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-binPROGRAMS
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \
clean-generic clean-libtool ctags distclean distclean-compile \
distclean-generic distclean-libtool distclean-tags distdir dvi \
dvi-am html html-am info info-am install install-am \
install-binPROGRAMS install-data install-data-am install-dvi \
install-dvi-am install-exec install-exec-am install-html \
install-html-am install-info install-info-am install-man \
install-pdf install-pdf-am install-ps install-ps-am \
install-strip installcheck installcheck-am installdirs \
maintainer-clean maintainer-clean-generic mostlyclean \
mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
pdf pdf-am ps ps-am tags uninstall uninstall-am \
uninstall-binPROGRAMS
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

615
test/unittest/libunit.c
Unescape View File

@ -0,0 +1,615 @@
/* vim: set textwidth=80 tabstop=4: */
/*
// libunit.c
//
// Copyright 2010 Michael Rasmussen <mir@datanom.net>
//
// 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, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
// MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "caldav.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <glib.h>
#include <string.h>
#include <sys/time.h>
#include <string.h>
static const char* usage[] = {
"unittest is part of libcaldav for claws-mails "
"vcalendar plugin.\nCopyright (C) Michael Rasmussen, 2008.\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\nusage:\n\tunittest [Options]\n"
"\n\tOptions:\n"
"\t\t-h|-?\tusage\n"
"\t\t-a\tURL\n"
"\t\t-d\tEnable debug\n"
"\t\t-l\tDebug library\n"
"\t\t-p\tpassword\n"
"\t\t-u\tusername\n"
};
/*
* Options can be given in one of three ways:
* 1) Entered as options on the command line
* 2) Stored in environment variables:
* - LIBCALDAV_UID -> username to use when connection to server
* - LIBCALDAV_PWD -> password, if any, to use when connection to server
* - LIBCALDAV_URL -> complete URL to server. prefixed with either
* http:// or https://
* 3) Stored in a file found in the same directory as the program:
* [server]
* password=Big secret
* username=username
* url=http[s]://bar.tld/foo
*/
#define CONFFILE "caldav-unit-settings.conf"
typedef struct {
gchar* uid;
gchar* pwd;
gchar* url;
} settings;
typedef enum {
PWD,
UID,
URL
} CONFIG;
static settings* SETTING = NULL;
gboolean DEBUG = FALSE;
gboolean DEBUG_LIB = FALSE;
void settings_free(settings** setting) {
settings* s;
if (! *setting)
return;
s = *setting;
g_free(s->url);
g_free(s->uid);
g_free(s->pwd);
g_free(s);
*setting = s = NULL;
}
settings* parse_cmdline(int argc, char** argv) {
char c;
settings* setting;
setting = g_new0(settings, 1);
while ((c = getopt(argc, argv, "ha:dlp:u:?")) != -1) {
switch (c) {
case 'h':
case '?':
fprintf(stdout, "%s", usage[0]);
return 0;
case 'a':
setting->url = g_strdup(optarg);
break;
case 'd':
DEBUG = TRUE;
break;
case 'l':
DEBUG_LIB = TRUE;
break;
case 'p':
setting->pwd = g_strdup(optarg);
break;
case 'u':
setting->uid = g_strdup(optarg);
break;
}
}
if (argv[optind]) {
fprintf(stderr, "No arguments after options expected\n");
fprintf(stderr, "%s", usage[0]);
settings_free(&setting);
return NULL;
}
return setting;
}
void read_file(const gchar* file) {
GKeyFile* keyfile;
if (! SETTING) {
SETTING = g_new0(settings, 1);
keyfile = g_key_file_new();
if (g_key_file_load_from_file(keyfile,
file,
G_KEY_FILE_KEEP_COMMENTS,
NULL)) {
SETTING->pwd = g_key_file_get_string(keyfile,
"server",
"password",
NULL);
SETTING->uid = g_key_file_get_string(keyfile,
"server",
"username",
NULL);
SETTING->url = g_key_file_get_string(keyfile,
"server",
"url",
NULL);
}
g_key_file_free(keyfile);
}
}
const gchar* get_setting_from_file(CONFIG config) {
gchar* cwd;
gchar* path;
gchar* pos;
gchar* setting = NULL;
int step;
gchar* filename = g_get_prgname();
if (filename[0] == '/') {
/* absolute path */
cwd = g_path_get_dirname(filename);
}
else if ((pos = strchr(filename, '/')) != NULL) {
/* relative path */
if (filename[0] == '.') {
char* tmp = pos;
while (tmp) {
if (strncmp(tmp, "..", 2) == 0)
step = 2;
else
step = 1;
tmp = strchr(pos + step, '/');
if (tmp)
pos = tmp;
}
if (pos == NULL) {
pos = strchr(filename, '/');
}
}
path = g_get_current_dir();
cwd = g_build_filename(path, pos + 1, NULL);
g_free(path);
if (g_file_test(cwd, G_FILE_TEST_IS_REGULAR)) {
pos = strrchr(cwd, '/');
if (pos) {
path = g_strndup(cwd, pos - cwd);
g_free(cwd);
cwd = g_strdup(path);
g_free(path);
}
}
}
else {
/* find cwd in PATH */
cwd = g_find_program_in_path(filename);
}
path = g_build_filename(cwd, CONFFILE, NULL);
g_free(cwd);
if (g_file_test(path, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
read_file(path);
switch (config) {
case UID: setting = SETTING->uid; break;
case PWD: setting = SETTING->pwd; break;
case URL: setting = SETTING->url; break;
}
}
g_free(path);
return setting;
}
gboolean find_missing(settings** setting) {
settings* s = *setting;
const char* env;
gboolean error = FALSE;
if (! s)
return TRUE;
if (! s->uid) {
if ((env = getenv("LIBCALDAV_UID")) == NULL) {
env = get_setting_from_file(UID);
if (env == NULL)
error = TRUE;
}
s->uid = g_strdup(env);
}
if (! s->pwd) {
if ((env = getenv("LIBCALDAV_PWD")) == NULL) {
env = get_setting_from_file(PWD);
if (env == NULL)
error = TRUE;
}
s->pwd = g_strdup(env);
}
if (! s->url) {
if ((env = getenv("LIBCALDAV_URL")) == NULL) {
env = get_setting_from_file(URL);
if (env == NULL)
error = TRUE;
}
s->url = g_strdup(env);
}
settings_free(&SETTING);
return error;
}
time_t make_time_t(const char* time_elem) {
struct tm datetime = {0,0,0,0,0,0,0,0,0,0,NULL};
struct tm* tmp;
gchar** elem;
time_t t;
t = time(NULL);
tmp = localtime(&t);
elem = g_strsplit(time_elem, "/", 3);
datetime.tm_year = atoi(elem[0]) - 1900;
datetime.tm_mon = atoi(elem[1]) - 1;
datetime.tm_mday = atoi(elem[2]);
g_strfreev(elem);
t = mktime(&datetime);
return t;
}
gboolean compare_freebusy(const gchar* s1, const gchar* s2) {
const char* TOKEN = "FREEBUSY:";
gchar* pos1;
gchar* pos2;
gchar* id1;
if (! s1 && ! s2)
return TRUE;
if (! s1 || ! s2)
return FALSE;
pos1 = strstr(s2, TOKEN);
if (! pos1)
return FALSE;
pos1 += strlen(TOKEN);
pos2 = strchr(pos1, '\n');
if (! pos2)
return FALSE;
if (*(pos2 - 1) == '\r')
pos2--;
id1 = g_strndup(pos1, pos2 - pos1);
int res = strcmp(s1, id1);
g_free(id1);
return (res == 0);
}
gboolean compare_object(const gchar* TOKEN, const gchar* s1, const gchar* s2) {
gchar* pos1;
gchar* pos2;
gchar* id1;
gchar* id2;
if (! s1 && ! s2)
return TRUE;
if (! s1 || ! s2)
return FALSE;
pos1 = strstr(s1, TOKEN);
if (! pos1)
return FALSE;
pos1 += strlen(TOKEN) + 1;
pos2 = strchr(pos1, '\n');
if (! pos2)
return FALSE;
if (*(pos2 - 1) == '\r')
pos2--;
id1 = g_strndup(pos1, pos2 - pos1);
pos2 = strstr(s2, TOKEN);
if (! pos2) {
g_free(id1);
return FALSE;
}
pos2 += strlen(TOKEN) + 1;
pos1 = strchr(pos2, '\n');
if (! pos1) {
g_free(id1);
return FALSE;
}
if (*(pos1 - 1) == '\r')
pos1--;
id2 = g_strndup(pos2, pos1 - pos2);
int res = strcmp(id1, id2);
g_free(id1);
g_free(id2);
return (res == 0);
}
void run_tests(settings* s) {
runtime_info* info = caldav_get_runtime_info();
response* resp = caldav_get_response();
gchar** parts;
gchar* url;
gchar* object;
if (DEBUG_LIB) {
info->options->debug = 1;
info->options->trace_ascii = 1;
}
parts = g_strsplit(s->url, "//", 2);
url = g_strconcat(
parts[0], "//", s->uid, ":", s->pwd, "@", parts[1], NULL);
g_strfreev(parts);
fprintf(stdout, "Test caldav_enabled_resource:\t\t\t");
if (caldav_enabled_resource(url, info)) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "caldav enabled server\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test caldav_get_displayname:\t\t\t");
if (caldav_get_displayname(resp, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Display Name: %s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
fprintf(stdout, "Test caldav_get_server_options:\t\t\t");
if ((parts = caldav_get_server_options(url, info)) != NULL) {
fprintf(stdout, "OK\n");
if (DEBUG) {
char** tmp = parts;
while (*tmp) {
fprintf(stdout, "--> %s\n", *tmp++);
}
}
g_strfreev(parts);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_file_get_contents("../ics/add.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_add_object:\t\t\t\t");
if (caldav_add_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Added successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was added:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/15"),
make_time_t("2008/04/16"), url, info) == OK) {
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
g_free(object);
fprintf(stdout, "Test FREEBUSY search the same day:\t\t");
if (caldav_get_freebusy(resp, make_time_t("2008/04/15"),
make_time_t("2008/04/16"), url, info) == OK) {
if (compare_freebusy("20080415T151500Z/20080415T162500", resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
g_file_get_contents("../ics/modify.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_modify_object:\t\t\t");
if (caldav_modify_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Modified successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was modified:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/16"),
make_time_t("2008/04/17"), url, info) == OK) {
if (compare_object("DTEND", object, resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
fprintf(stdout, "Test caldav_getall_object:\t\t\t");
if (caldav_getall_object(resp, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object exists:\t\t\t\t");
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "FAIL\n");
else
fprintf(stdout, "OK\n");
g_free(resp->msg);
resp->msg = NULL;
g_free(object);
g_file_get_contents("../ics/delete.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_delete_object:\t\t\t");
if (caldav_delete_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Deleted successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was deleted:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/16"),
make_time_t("2008/04/17"), url, info) == OK) {
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "FAIL\n");
else
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "%s\n", (resp->msg) ? resp->msg : "No object found");
g_free(resp->msg);
resp->msg = NULL;
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(object);
fprintf(stdout, "\nTesting without using locks\n");
info->options->use_locking = 0;
g_file_get_contents("../ics/add.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_add_object:\t\t\t\t");
if (caldav_add_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Added successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was added:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/15"),
make_time_t("2008/04/16"), url, info) == OK) {
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
g_free(object);
/* fprintf(stdout, "Test FREEBUSY search the same day:\t\t");
if (caldav_get_freebusy(resp, make_time_t("2008/04/15"),
make_time_t("2008/04/16"), url, info) == OK) {
if (compare_freebusy("20080415T151500Z/20080415T162500", resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;*/
g_file_get_contents("../ics/modify.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_modify_object:\t\t\t");
if (caldav_modify_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Modified successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was modified:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/16"),
make_time_t("2008/04/17"), url, info) == OK) {
if (compare_object("DTEND", object, resp->msg))
fprintf(stdout, "OK\n");
else
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%s\n", resp->msg);
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(resp->msg);
resp->msg = NULL;
g_free(object);
g_file_get_contents("../ics/delete.ics", &object, NULL, NULL);
fprintf(stdout, "Test caldav_delete_object:\t\t\t");
if (caldav_delete_object(object, url, info) == OK) {
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "Deleted successfully\n");
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
fprintf(stdout, "Test if object was deleted:\t\t\t");
if (caldav_get_object(resp, make_time_t("2008/04/16"),
make_time_t("2008/04/17"), url, info) == OK) {
if (compare_object("UID", object, resp->msg))
fprintf(stdout, "FAIL\n");
else
fprintf(stdout, "OK\n");
if (DEBUG) fprintf(stdout, "%s\n", (resp->msg) ? resp->msg : "No object found");
g_free(resp->msg);
resp->msg = NULL;
}
else {
fprintf(stdout, "FAIL\n");
if (DEBUG) fprintf(stdout, "%ld: %s\n", info->error->code, info->error->str);
}
g_free(url);
caldav_free_response(&resp);
caldav_free_runtime_info(&info);
}
int main(int argc, char** argv) {
settings* setting;
g_set_prgname(argv[0]);
setting = parse_cmdline(argc, argv);
if (find_missing(&setting)) {
fprintf(stderr, "missing required information\n");
fprintf(stdout, "%s", usage[0]);
settings_free(&setting);
return 1;
}
run_tests(setting);
settings_free(&setting);
return 0;
}

10
version.sh
Unescape View File

@ -0,0 +1,10 @@
#!/bin/sh
if [ "x$1" = "xLIBTOOL" ]; then
grep -m 1 libcaldav ChangeLog | awk '{print $2}' | \
cut -c2-4 | sed 's/\./:/g'
else
grep -m 1 libcaldav ChangeLog | awk '{print $2}' | cut -c2-6
fi
exit 0
Write Preview
Loading…
Cancel
Save