pax_global_header 0000666 0000000 0000000 00000000064 13757173071 0014525 g ustar 00root root 0000000 0000000 52 comment=50c26d8b586b53c00fc36fe89d071fddb2437c80
bctoolbox-4.4.13/ 0000775 0000000 0000000 00000000000 13757173071 0013611 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/.gitignore 0000664 0000000 0000000 00000000017 13757173071 0015577 0 ustar 00root root 0000000 0000000 bctoolbox.spec
bctoolbox-4.4.13/CHANGELOG.md 0000664 0000000 0000000 00000002063 13757173071 0015423 0 ustar 00root root 0000000 0000000 # Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [Unreleased]
## [4.4.0] - 2020-6-09
### Changed
- Version number now follows linphone-sdk's versionning.
### Removed
- Polarssl 1.2 support.
## [0.6.0] - 2017-07-20
### Added
- Add API to escape/unescape strings (SIP, VCARD).
## [0.5.1] - 2017-02-22
### Added
- "const char * to void *" map feature
### Fixed
- security bugfix: TLS session could be successfully established whereas the common
name did not match the server name.
## [0.2.0] - 2016-08-08
### Added
- Creating a Virtual File System bctbx_vfs allowing direct file access and I/Os.
- integrate OS abstraction layer, list API, logging API from oRTP
- integrate getaddrinfo() abstraction api, in order to provide consistent getaddrinfo() support on all platforms.
## [0.0.1] - 2016-01-01
### Added
- Initial release.
### Changed
### Removed
bctoolbox-4.4.13/CMakeLists.txt 0000664 0000000 0000000 00000015724 13757173071 0016362 0 ustar 00root root 0000000 0000000 ############################################################################
# CMakeLists.txt
# Copyright (C) 2010-2019 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
cmake_minimum_required(VERSION 3.2)
set(CMAKE_MACOSX_RPATH ON) # Before cmake 3.0.0, MACOSX_RPATH was not set to ON by default - however this is no good reason to not enable it by default
project(bctoolbox VERSION 4.4.0)
set(BCTOOLBOX_VERSION "${PROJECT_VERSION}")
set(BCTOOLBOX_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
set(BCTOOLBOX_VERSION_MINOR ${PROJECT_VERSION_MINOR})
set(BCTOOLBOX_VERSION_PATCH ${PROJECT_VERSION_PATCH})
set(BCTOOLBOX_SO_VERSION 1)
set(BCTOOLBOXTESTER_SO_VERSION 1)
option(ENABLE_SHARED "Build shared library." ON)
option(ENABLE_STATIC "Build static library." ON)
option(ENABLE_POLARSSL "Enable polarssl support" ON)
option(ENABLE_MBEDTLS "Enable mabedtls support" ON)
option(ENABLE_DECAF "Enable Elliptic Curve Cryptography support" ON)
option(ENABLE_STRICT "Pass strict flags to the compiler" ON)
option(ENABLE_TESTS_COMPONENT "Enable compilation of tests helper library" ON)
option(ENABLE_TESTS "Enable compilation of tests" ON)
option(ENABLE_PACKAGE_SOURCE "Create 'package_source' target for source archive making (CMake >= 3.11)" OFF)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_EXTENSIONS NO)
include(CheckLibraryExists)
include(CheckSymbolExists)
include(CheckCSourceCompiles)
include(CMakePushCheckState)
include(GNUInstallDirs)
include(cmake/BcToolboxCMakeUtils.cmake)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
if(NOT CPACK_GENERATOR AND NOT CMAKE_INSTALL_RPATH AND CMAKE_INSTALL_PREFIX)
set(CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR})
message(STATUS "Setting install rpath to ${CMAKE_INSTALL_RPATH}")
endif()
if(APPLE)
find_package(Iconv REQUIRED)
endif()
if(ENABLE_MBEDTLS)
find_package(MbedTLS)
if(MBEDTLS_FOUND)
message(STATUS "Using mbedTLS")
set(HAVE_MBEDTLS 1)
endif()
endif()
if(ENABLE_DECAF)
find_package(Decaf CONFIG)
if(DECAF_FOUND)
message(STATUS "Using Decaf")
set(HAVE_DECAF 1)
endif()
endif()
if(ENABLE_POLARSSL AND NOT MBEDTLS_FOUND)
find_package(PolarSSL REQUIRED)
if(POLARSSL_FOUND)
message(STATUS "Using polarSSL")
set(HAVE_POLARSSL 1)
if(CTR_DRBG_FREE)
set(HAVE_CTR_DRGB_FREE 1)
endif()
endif()
endif()
if(HAVE_SSL_GET_DTLS_SRTP_PROTECTION_PROFILE)
message(STATUS "DTLS SRTP available")
set(HAVE_DTLS_SRTP 1)
else()
message(STATUS "DTLS SRTP not available")
endif()
if(MBEDTLS_FOUND)
get_filename_component(mbedtls_library_path "${MBEDTLS_LIBRARIES}" PATH)
string(REPLACE ";" " " MBEDTLS_LIBRARIES_STR "${MBEDTLS_LIBRARIES}")
set(LIBS_PRIVATE "${LIBS_PRIVATE} ${MBEDTLS_LIBRARIES_STR}")
endif()
if(POLARSSL_FOUND)
get_filename_component(polarssl_library_path "${POLARSSL_LIBRARIES}" PATH)
set(LIBS_PRIVATE "${LIBS_PRIVATE} -L${polarssl_library_path} -lpolarssl")
endif()
if(ENABLE_TESTS_COMPONENT)
find_package(BcUnit CONFIG REQUIRED)
cmake_push_check_state(RESET)
list(APPEND CMAKE_REQUIRED_INCLUDES ${BCUNIT_INCLUDE_DIRS})
list(APPEND CMAKE_REQUIRED_LIBRARIES ${BCUNIT_LIBRARIES})
check_symbol_exists("CU_get_suite" "BCUnit/BCUnit.h" HAVE_CU_GET_SUITE)
check_symbol_exists("CU_curses_run_tests" "BCUnit/BCUnit.h" HAVE_CU_CURSES)
check_symbol_exists("CU_set_trace_handler" "BCUnit/Util.h" HAVE_CU_SET_TRACE_HANDLER)
cmake_pop_check_state()
set(TESTER_REQUIRES_PRIVATE "bcunit")
endif()
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/bctoolbox.pc.in ${CMAKE_CURRENT_BINARY_DIR}/bctoolbox.pc)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/bctoolbox.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
if(ENABLE_TESTS_COMPONENT)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/bctoolbox-tester.pc.in ${CMAKE_CURRENT_BINARY_DIR}/bctoolbox-tester.pc)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/bctoolbox-tester.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
endif()
find_package(Threads REQUIRED)
include_directories(
include
src
${CMAKE_CURRENT_BINARY_DIR}
)
set(BCTOOLBOX_CPPFLAGS )
if(ENABLE_STATIC)
set(BCTBX_STATIC 1)
list(APPEND BCTOOLBOX_CPPFLAGS "-DBCTBX_STATIC")
endif()
bc_init_compilation_flags(STRICT_OPTIONS_CPP STRICT_OPTIONS_C STRICT_OPTIONS_CXX ENABLE_STRICT)
if(CMAKE_VERSION VERSION_LESS 3.1 AND NOT APPLE AND NOT MSVC)
list(APPEND STRICT_OPTIONS_CXX "-std=c++11")
endif()
set(EXPORT_TARGETS_NAME "bctoolbox")
check_library_exists("rt" "clock_gettime" "" HAVE_LIBRT)
check_library_exists("dl" "dladdr" "" HAVE_LIBDL)
check_include_file("execinfo.h" HAVE_EXECINFO)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h)
set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/config.h PROPERTIES GENERATED ON)
add_definitions("-DHAVE_CONFIG_H")
add_subdirectory(include)
add_subdirectory(src)
if(ENABLE_TESTS AND ENABLE_TESTS_COMPONENT)
add_subdirectory(tester)
endif()
if(ENABLE_PACKAGE_SOURCE)
add_subdirectory(build)
endif()
include(CMakePackageConfigHelpers)
set(CONFIG_PACKAGE_LOCATION "${CMAKE_INSTALL_DATADIR}/${PROJECT_NAME}/cmake")
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/${EXPORT_TARGETS_NAME}ConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
configure_package_config_file(cmake/BcToolboxConfig.cmake.in
"${CMAKE_CURRENT_BINARY_DIR}/${EXPORT_TARGETS_NAME}Config.cmake"
INSTALL_DESTINATION ${CONFIG_PACKAGE_LOCATION}
NO_SET_AND_CHECK_MACRO
)
configure_file(cmake/BcToolboxCMakeUtils.cmake "${CMAKE_CURRENT_BINARY_DIR}/${EXPORT_TARGETS_NAME}CMakeUtils.cmake" COPYONLY)
configure_file(cmake/BcGitVersion.cmake "${CMAKE_CURRENT_BINARY_DIR}/BcGitVersion.cmake" COPYONLY)
configure_file(cmake/gitversion.h.in "${CMAKE_CURRENT_BINARY_DIR}/gitversion.h.in" COPYONLY)
install(EXPORT ${EXPORT_TARGETS_NAME}Targets
FILE "${EXPORT_TARGETS_NAME}Targets.cmake"
DESTINATION ${CONFIG_PACKAGE_LOCATION}
)
install(FILES
"cmake/MakeArchive.cmake"
"cmake/ConfigureSpecfile.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${EXPORT_TARGETS_NAME}Config.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${EXPORT_TARGETS_NAME}ConfigVersion.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/${EXPORT_TARGETS_NAME}CMakeUtils.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/BcGitVersion.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/gitversion.h.in"
DESTINATION ${CONFIG_PACKAGE_LOCATION}
)
bctoolbox-4.4.13/LICENSE.txt 0000664 0000000 0000000 00000077331 13757173071 0015447 0 ustar 00root root 0000000 0000000 GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
bctoolbox-4.4.13/README.md 0000664 0000000 0000000 00000004005 13757173071 0015067 0 ustar 00root root 0000000 0000000 [](https://gitlab.linphone.org/BC/public/bctoolbox/commits/master)
BcToolbox
=========
Utilities library used by Belledonne Communications softwares like belle-sip, mediastreamer2 and liblinphone.
Depends
-------
- **mbedtls[1]**: implementation of TLS interface of BcToolbox. For backward
compatibility, support of polarssl is also provided.
- **bcunit[2]** for unitary test tools. (optional)
To compile
----------
cmake . -DCMAKE_INSTALL_PREFIX= -DCMAKE_PREFIX_PATH=
make
make install
To make an rpm package
----------------------
cmake . -DCMAKE_INSTALL_PREFIX=/usr -DCPACK_GENERATOR="RPM"
make package
Options
-------
- `CMAKE_INSTALL_PREFIX=`: install prefix.
- `CMAKE_PREFIX_PATH=`: search path prefix for dependencies e.g. mbedtls.
- `ENABLE_MBEDTLS=NO`: do not look for mbedtls. Then, polarssl will be selected.
- `ENABLE_POLARSSL=NO`: do not look for polarssl. That ensure to use mbedtls.
- `ENABLE_SHARED=NO`: do not build the shared libraries.
- `ENABLE_STATIC=NO`: do not build the static libraries.
- `ENABLE_STRICT=NO`: do not build with strict compilator flags e.g. `-Wall -Werror`.
- `ENABLE_TESTS=NO`: do not build testing binaries.
- `ENABLE_TESTS_COMPONENT=NO`: do not build libbctoolbox-tester.
Notes
-----
For backward compatibility with distributions not having the required 2.8.12 cmake version, an automake/autoconf build system is also available.
It is maintained as a best effort and then should be used only in last resort.
Note for packagers
------------------
Our CMake scripts may automatically add some paths into research paths of generated binaries.
To ensure that the installed binaries are striped of any rpath, use `-DCMAKE_SKIP_INSTALL_RPATH=ON`
while you invoke cmake.
--------------------
- [1]
- [2] git://git.linphone.org/bctoolbox.git or
bctoolbox-4.4.13/bctoolbox-tester.pc.in 0000664 0000000 0000000 00000000560 13757173071 0020042 0 ustar 00root root 0000000 0000000 # This is a comment
prefix=@CMAKE_INSTALL_PREFIX@
exec_prefix=@CMAKE_INSTALL_PREFIX@
Name: bctoolbox-tester
Description: A common set of tester wrappers used by Belledonne Communications's softwares
Requires.private: @TESTER_REQUIRES_PRIVATE@
Version: @PROJECT_VERSION@
Libs: -L@CMAKE_INSTALL_FULL_LIBDIR@ -lbctoolbox-tester
Cflags: -I@CMAKE_INSTALL_FULL_INCLUDEDIR@
bctoolbox-4.4.13/bctoolbox.pc.in 0000664 0000000 0000000 00000000511 13757173071 0016532 0 ustar 00root root 0000000 0000000 # This is a comment
prefix=@CMAKE_INSTALL_PREFIX@
exec_prefix=@CMAKE_INSTALL_PREFIX@
Name: bctoolbox
Description: A common set of tools used by Belledonne Communication's softwares
Version: @PROJECT_VERSION@
Libs: -L@CMAKE_INSTALL_FULL_LIBDIR@ -lbctoolbox
Libs.private: @LIBS_PRIVATE@
Cflags: -I@CMAKE_INSTALL_FULL_INCLUDEDIR@
bctoolbox-4.4.13/build/ 0000775 0000000 0000000 00000000000 13757173071 0014710 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/build/CMakeLists.txt 0000664 0000000 0000000 00000003002 13757173071 0017443 0 ustar 00root root 0000000 0000000 ############################################################################
# CMakeLists.txt
# Copyright (C) 2010-2019 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
cmake_minimum_required(VERSION 3.11) # we need CMake 3.11 for defining 'package_source' target as custom target
set(BCTOOLBOX_CMAKE_DIR "${PROJECT_SOURCE_DIR}/cmake")
set(BCTOOLBOX_CMAKE_UTILS "${BCTOOLBOX_CMAKE_DIR}/BcToolboxCMakeUtils.cmake")
include("${BCTOOLBOX_CMAKE_DIR}/BcToolboxCMakeUtils.cmake")
if(NOT CPACK_PACKAGE_NAME)
set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
endif()
set(CPACK_SOURCE_IGNORE_FILES
"^${CMAKE_BINARY_DIR}"
"^${PROJECT_SOURCE_DIR}/.git*"
)
bc_make_package_source_target()
bctoolbox-4.4.13/build/android/ 0000775 0000000 0000000 00000000000 13757173071 0016330 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/build/android/Android-mbedtls.mk 0000664 0000000 0000000 00000000602 13757173071 0021667 0 ustar 00root root 0000000 0000000
LOCAL_PATH:= $(call my-dir)/../../src/
include $(CLEAR_VARS)
LOCAL_MODULE:= libbctoolbox
LOCAL_SRC_FILES := \
crypto/mbedtls.c
LOCAL_CFLAGS += -Wno-maybe-uninitialized -DHAVE_DTLS_SRTP
LOCAL_C_INCLUDES += \
$(LOCAL_PATH)/ \
$(LOCAL_PATH)/../include \
$(LOCAL_PATH)/../../externals/mbedtls/include
LOCAL_STATIC_LIBRARIES := \
mbedtls
include $(BUILD_STATIC_LIBRARY)
bctoolbox-4.4.13/build/android/Android-polarssl.mk 0000664 0000000 0000000 00000000605 13757173071 0022077 0 ustar 00root root 0000000 0000000
LOCAL_PATH:= $(call my-dir)/../../src/
include $(CLEAR_VARS)
LOCAL_MODULE:= libbctoolbox
LOCAL_SRC_FILES := \
crypto/polarssl.c
LOCAL_CFLAGS += -Wno-maybe-uninitialized -DHAVE_DTLS_SRTP
LOCAL_C_INCLUDES += \
$(LOCAL_PATH)/ \
$(LOCAL_PATH)/../include \
$(LOCAL_PATH)/../../externals/polarssl/include
LOCAL_STATIC_LIBRARIES := \
polarssl
include $(BUILD_STATIC_LIBRARY)
bctoolbox-4.4.13/build/android/Android-tester.mk 0000664 0000000 0000000 00000000624 13757173071 0021547 0 ustar 00root root 0000000 0000000 LOCAL_PATH:= $(call my-dir)/../../src/
include $(CLEAR_VARS)
LOCAL_MODULE:= libbctoolbox_tester
LOCAL_SRC_FILES := \
tester/utils.c
LOCAL_CFLAGS += -Wno-maybe-uninitialized -DIN_BCUNIT_SOURCES -DHAVE_CU_SET_TRACE_HANDLER=1 -DHAVE_CU_GET_SUITE=1
LOCAL_C_INCLUDES += \
$(LOCAL_PATH)/ \
$(LOCAL_PATH)/../include \
$(LOCAL_PATH)/../../externals/bcunit/BCUnit/Headers
include $(BUILD_STATIC_LIBRARY)
bctoolbox-4.4.13/build/osx/ 0000775 0000000 0000000 00000000000 13757173071 0015521 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/build/osx/Info.plist.in 0000664 0000000 0000000 00000002611 13757173071 0020076 0 ustar 00root root 0000000 0000000
CFBundleDevelopmentRegion
English
CFBundleExecutable
${MACOSX_FRAMEWORK_NAME}
CFBundleGetInfoString
${MACOSX_BUNDLE_INFO_STRING}
CFBundleIconFile
${MACOSX_BUNDLE_ICON_FILE}
CFBundleIdentifier
${MACOSX_FRAMEWORK_IDENTIFIER}
LSMinimumSystemVersion
${MIN_OS}
MinimumOSVersion
${MIN_OS}
CFBundleInfoDictionaryVersion
6.0
CFBundleLongVersionString
${MACOSX_BUNDLE_LONG_VERSION_STRING}
CFBundleName
${MACOSX_BUNDLE_BUNDLE_NAME}
CFBundlePackageType
FMWK
CFBundleShortVersionString
${BCTOOLBOX_VERSION}
CFBundleSignature
????
CFBundleVersion
${BCTOOLBOX_VERSION}
CSResourcesFileMapped
NSHumanReadableCopyright
${MACOSX_BUNDLE_COPYRIGHT}
NSPrincipalClass
NSApplication
NSHighResolutionCapable
True
bctoolbox-4.4.13/build/rpm/ 0000775 0000000 0000000 00000000000 13757173071 0015506 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/build/rpm/bctoolbox.spec.cmake 0000775 0000000 0000000 00000005523 13757173071 0021444 0 ustar 00root root 0000000 0000000 # -*- rpm-spec -*-
%define _prefix @CMAKE_INSTALL_PREFIX@
%define pkg_prefix @BC_PACKAGE_NAME_PREFIX@
%define package_name @CPACK_PACKAGE_NAME@-${FULL_VERSION}
# re-define some directories for older RPMBuild versions which don't. This messes up the doc/ dir
# taken from https://fedoraproject.org/wiki/Packaging:RPMMacros?rd=Packaging/RPMMacros
%define _datarootdir %{_prefix}/share
%define _datadir %{_datarootdir}
%define _docdir %{_datadir}/doc
Name: @CPACK_PACKAGE_NAME@
Version: ${RPM_VERSION}
Release: ${RPM_RELEASE}%{?dist}
Summary: OS abstraction layer and utilities
Group: Applications/Communications
License: GPL
URL: http://www.linphone.org
Source0: %{package_name}.tar.gz
BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot
Requires: %{pkg_prefix}bctoolbox
%description
Toolbox package used by Belledonne Communications projects
%package devel
Summary: Development libraries for bctoolbox
Group: Development/Libraries
Requires: %{name} = %{version}-%{release}
%description devel
Libraries and headers required to develop software with bctoolbox
%if 0%{?rhel} && 0%{?rhel} <= 7
%global cmake_name cmake3
%define ctest_name ctest3
%else
%global cmake_name cmake
%define ctest_name ctest
%endif
# This is for debian builds where debug_package has to be manually specified, whereas in centos it does not
%define custom_debug_package %{!?_enable_debug_packages:%debug_package}%{?_enable_debug_package:%{nil}}
%custom_debug_package
%prep
%setup -n %{package_name}
%build
%{expand:%%%cmake_name} . -DCMAKE_BUILD_TYPE=@CMAKE_BUILD_TYPE@ -DCMAKE_PREFIX_PATH:PATH=%{_prefix} @RPM_ALL_CMAKE_OPTIONS@
make %{?_smp_mflags}
%install
make install DESTDIR=%{buildroot}
# Dirty workaround to give exec rights for all shared libraries. Debian packaging needs this
# TODO : set CMAKE_INSTALL_SO_NO_EXE for a cleaner workaround
chmod +x `find %{buildroot} *.so.*`
%check
%{ctest_name} -V %{?_smp_mflags}
%clean
rm -rf $RPM_BUILD_ROOT
%post -p /sbin/ldconfig
%postun -p /sbin/ldconfig
%files
%defattr(-,root,root)
%doc LICENSE.txt CHANGELOG.md README.md
%{_libdir}/*.so.*
%files devel
%defattr(-,root,root)
%{_includedir}/bctoolbox
%if @ENABLE_STATIC@
%{_libdir}/libbctoolbox.a
%endif
%if @ENABLE_SHARED@
%{_libdir}/libbctoolbox.so
%endif
%{_libdir}/pkgconfig/bctoolbox.pc
%{_datadir}/bctoolbox/cmake/*
%if @ENABLE_TESTS_COMPONENT@
%if @ENABLE_STATIC@
%{_libdir}/libbctoolbox-tester.a
%endif
%if @ENABLE_SHARED@
%{_libdir}/libbctoolbox-tester.so
%endif
%{_libdir}/pkgconfig/bctoolbox-tester.pc
%endif
%changelog
* Tue Nov 27 2018 ronan.abhamon
- Do not set CMAKE_INSTALL_LIBDIR and never with _libdir!
* Tue Jan 16 2018 Ghislain MARY
- Initial RPM release.
bctoolbox-4.4.13/cmake/ 0000775 0000000 0000000 00000000000 13757173071 0014671 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/cmake/BcGitVersion.cmake 0000664 0000000 0000000 00000004176 13757173071 0020241 0 ustar 00root root 0000000 0000000 ############################################################################
# BcGitVersion.cmake
# Copyright (C) 2017 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
if(GIT_EXECUTABLE)
macro(GIT_COMMAND OUTPUT_VAR)
set(GIT_ARGS ${ARGN})
execute_process(
COMMAND ${GIT_EXECUTABLE} ${ARGN}
WORKING_DIRECTORY ${WORK_DIR}
OUTPUT_VARIABLE ${OUTPUT_VAR}
OUTPUT_STRIP_TRAILING_WHITESPACE
)
endmacro()
GIT_COMMAND(GIT_DESCRIBE describe --always)
GIT_COMMAND(GIT_TAG describe --abbrev=0)
GIT_COMMAND(GIT_REVISION rev-parse HEAD)
endif()
string(TOUPPER "${PROJECT_NAME}" PREFIX_GIT_VERSION)
string(REPLACE "-" "_" PREFIX_GIT_VERSION "${PREFIX_GIT_VERSION}")
if(GIT_DESCRIBE)
if(NOT GIT_TAG STREQUAL PROJECT_VERSION)
message(WARNING "Project version (${PROJECT_VERSION}) and git tag (${GIT_TAG}) differ. Please put them identical")
endif()
set(PROJECT_GIT_VERSION "${GIT_DESCRIBE}")
configure_file("${TEMPLATE_DIR}/gitversion.h.in" "${OUTPUT_DIR}/gitversion.h" @ONLY)
elseif(GIT_REVISION)
set(PROJECT_GIT_VERSION "${LINPHONE_VERSION}_${GIT_REVISION}")
configure_file("${TEMPLATE_DIR}/gitversion.h.in" "${OUTPUT_DIR}/gitversion.h" @ONLY)
else()
if(NOT EXISTS "${OUTPUT_DIR}/gitversion.h")
execute_process(COMMAND ${CMAKE_COMMAND} -E touch "${OUTPUT_DIR}/gitversion.h")
endif()
endif()
bctoolbox-4.4.13/cmake/BcToolboxCMakeUtils.cmake 0000664 0000000 0000000 00000024073 13757173071 0021516 0 ustar 00root root 0000000 0000000 ############################################################################
# BcToolboxCMakeUtils.cmake
# Copyright (C) 2010-2019 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
set(BCTOOLBOX_CMAKE_UTILS_DIR "${CMAKE_CURRENT_LIST_DIR}")
macro(bc_init_compilation_flags CPP_FLAGS C_FLAGS CXX_FLAGS STRICT_COMPILATION)
set(${CPP_FLAGS} )
set(${C_FLAGS} )
set(${CXX_FLAGS} )
if(MSVC)
if(${STRICT_COMPILATION})
list(APPEND ${CPP_FLAGS} "/WX")
list(APPEND STRICT_OPTIONS_CPP "/wd4996") # Disable deprecated function warnings
endif()
else()
list(APPEND ${CPP_FLAGS} "-Wall" "-Wuninitialized")
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
list(APPEND ${CPP_FLAGS} "-Wno-error=unknown-warning-option" "-Qunused-arguments" "-Wno-tautological-compare" "-Wno-builtin-requires-header" "-Wno-unused-function" "-Wno-gnu-designator" "-Wno-array-bounds")
elseif(CMAKE_C_COMPILER_ID STREQUAL "GNU")
list(APPEND ${CPP_FLAGS} "-Wno-error=pragmas")
endif()
if(APPLE)
list(APPEND ${CPP_FLAGS} "-Wno-error=unknown-warning-option" "-Qunused-arguments" "-Wno-tautological-compare" "-Wno-unused-function" "-Wno-array-bounds")
endif()
if(ENABLE_STRICT)
list(APPEND ${CPP_FLAGS} "-Werror" "-Wextra" "-Wno-unused-parameter" "-Wno-error=unknown-pragmas" "-Wuninitialized" "-Wno-missing-field-initializers"
"-fno-strict-aliasing" "-Wno-error=deprecated" "-Wno-error=deprecated-declarations")
list(APPEND ${C_FLAGS} "-Werror" "-Wstrict-prototypes")
endif()
endif()
endmacro()
macro(bc_apply_compile_flags SOURCE_FILES)
if(${SOURCE_FILES})
set(options "")
foreach(a ${ARGN})
if(${a})
string(REPLACE ";" " " options_${a} "${${a}}")
set(options "${options} ${options_${a}}")
endif()
endforeach()
if(options)
set_source_files_properties(${${SOURCE_FILES}} PROPERTIES COMPILE_FLAGS "${options}")
endif()
endif()
endmacro()
macro(bc_git_version PROJECT_NAME PROJECT_VERSION)
find_package(Git)
add_custom_target(${PROJECT_NAME}-git-version
COMMAND ${CMAKE_COMMAND} -DGIT_EXECUTABLE=${GIT_EXECUTABLE} -DPROJECT_NAME=${PROJECT_NAME} -DPROJECT_VERSION=${PROJECT_VERSION} -DWORK_DIR=${CMAKE_CURRENT_SOURCE_DIR} -DTEMPLATE_DIR=${BCTOOLBOX_CMAKE_UTILS_DIR} -DOUTPUT_DIR=${CMAKE_CURRENT_BINARY_DIR} -P ${BCTOOLBOX_CMAKE_UTILS_DIR}/BcGitVersion.cmake
BYPRODUCTS "${CMAKE_CURRENT_BINARY_DIR}/gitversion.h"
)
endmacro()
# TODO remove this macro
macro(bc_project_build_version PROJECT_VERSION PROJECT_BUILD_VERSION)
find_program (WC wc)
if(WC)
set(GIT_MINIMUM_VERSION 1.7.1) #might be even lower
else()
set(GIT_MINIMUM_VERSION 1.7.10) # --count option of git rev-list is available only since (more or less) git 1.7.10)
endif()
find_package(Git ${GIT_MINIMUM_VERSION})
string(COMPARE GREATER "${GIT_VERSION_STRING}" "1.7.10" GIT_REV_LIST_HAS_COUNT)
if(GIT_REV_LIST_HAS_COUNT)
set(GIT_REV_LIST_COMMAND "${GIT_EXECUTABLE}" "rev-list" "--count" "${PROJECT_VERSION}..HEAD")
set(WC_COMMAND "more") #nop
else()
set(GIT_REV_LIST_COMMAND "${GIT_EXECUTABLE}" "rev-list" "${PROJECT_VERSION}..HEAD")
set(WC_COMMAND "${WC}" "-l")
endif()
if(GIT_EXECUTABLE)
execute_process(
COMMAND ${GIT_REV_LIST_COMMAND}
COMMAND ${WC_COMMAND}
OUTPUT_VARIABLE PROJECT_VERSION_BUILD
OUTPUT_STRIP_TRAILING_WHITESPACE
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
endif()
if (NOT PROJECT_VERSION_BUILD)
set(PROJECT_VERSION_BUILD 0)
endif()
endmacro()
macro(bc_generate_rpm_specfile SOURCE DEST)
if(UNIX AND NOT APPLE AND NOT ANDROID)
set(BC_PACKAGE_NAME_PREFIX "" CACHE STRING "Prefix for name of package.")
get_cmake_property(_variableNames VARIABLES)
set(RPM_ALL_CMAKE_OPTIONS "")
foreach(_variableName ${_variableNames})
if(_variableName MATCHES "^ENABLE_")
if(${_variableName})
set(${_variableName} 1)
else()
set(${_variableName} 0)
endif()
set(RPM_ALL_CMAKE_OPTIONS "${RPM_ALL_CMAKE_OPTIONS} -D${_variableName}=${${_variableName}}")
endif()
endforeach()
configure_file(${SOURCE} ${DEST} @ONLY)
unset(RPM_ALL_CMAKE_OPTIONS)
unset(_variableNames)
endif()
endmacro()
function(bc_parse_full_version version major minor patch)
if ("${version}" MATCHES "^(0|[1-9][0-9]*)[.](0|[1-9][0-9]*)[.](0|[1-9][0-9]*)(-[.0-9A-Za-z-]+)?([+][.0-9A-Za-z-]+)?$")
set(${major} "${CMAKE_MATCH_1}" PARENT_SCOPE)
set(${minor} "${CMAKE_MATCH_2}" PARENT_SCOPE)
set(${patch} "${CMAKE_MATCH_3}" PARENT_SCOPE)
if (ARGC GREATER 4)
set(${ARGV4} "${CMAKE_MATCH_4}" PARENT_SCOPE)
endif()
if (ARGC GREATER 5)
set(${ARGV5} "${CMAKE_MATCH_5}" PARENT_SCOPE)
endif()
else()
message(FATAL_ERROR "invalid full version '${version}'")
endif()
endfunction()
function(bc_compute_lib_version OUTPUT_VERSION default_version)
find_program(GIT_EXECUTABLE git NAMES Git CMAKE_FIND_ROOT_PATH_BOTH)
if(GIT_EXECUTABLE)
execute_process(
COMMAND "${GIT_EXECUTABLE}" "describe"
OUTPUT_VARIABLE GIT_DESCRIBE_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_QUIET
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
)
# parse git describe version
if (NOT (GIT_DESCRIBE_VERSION MATCHES "^([0-9]+)[.]([0-9]+)[.]([0-9]+)(-alpha|-beta)?(-[0-9]+)?(-g[0-9a-f]+)?$"))
message(FATAL_ERROR "invalid git describe version: '${GIT_DESCRIBE_VERSION}'")
endif()
set(version_major ${CMAKE_MATCH_1})
set(version_minor ${CMAKE_MATCH_2})
set(version_patch ${CMAKE_MATCH_3})
# format lib version
set(${OUTPUT_VERSION} "${version_major}.${version_minor}.${version_patch}" CACHE STRING "")
else()
set(${OUTPUT_VERSION} "${default_version}" CACHE STRING "")
endif()
endfunction()
function(bc_compute_full_version OUTPUT_VERSION)
find_program(GIT_EXECUTABLE git NAMES Git CMAKE_FIND_ROOT_PATH_BOTH)
if(GIT_EXECUTABLE)
execute_process(
COMMAND "${GIT_EXECUTABLE}" "describe"
OUTPUT_VARIABLE GIT_DESCRIBE_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_QUIET
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
)
# parse git describe version
if (NOT (GIT_DESCRIBE_VERSION MATCHES "^([0-9]+)[.]([0-9]+)[.]([0-9]+)(-alpha|-beta)?(-[0-9]+)?(-g[0-9a-f]+)?$"))
message(FATAL_ERROR "invalid git describe version: '${GIT_DESCRIBE_VERSION}'")
endif()
set(version_major ${CMAKE_MATCH_1})
set(version_minor ${CMAKE_MATCH_2})
set(version_patch ${CMAKE_MATCH_3})
if (CMAKE_MATCH_4)
string(SUBSTRING "${CMAKE_MATCH_4}" 1 -1 version_prerelease)
endif()
if (CMAKE_MATCH_5)
string(SUBSTRING "${CMAKE_MATCH_5}" 1 -1 version_commit)
endif()
if (CMAKE_MATCH_6)
string(SUBSTRING "${CMAKE_MATCH_6}" 2 -1 version_hash)
endif()
# interpret untagged hotfixes as pre-releases of the next "patch" release
if (NOT version_prerelease AND version_commit)
math(EXPR version_patch "${version_patch} + 1")
set(version_prerelease "pre")
endif()
# format full version
set(full_version "${version_major}.${version_minor}.${version_patch}")
if (version_prerelease)
string(APPEND full_version "-${version_prerelease}")
if (version_commit)
string(APPEND full_version ".${version_commit}+${version_hash}")
endif()
endif()
# check that the major and minor versions declared by the `project()` command are equal to the ones
# that have been found out while parsing `git describe` result.
if (PROJECT_VERSION)
set(short_git_version "${version_major}.${version_minor}")
set(short_project_version "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}")
if(NOT (short_project_version VERSION_EQUAL short_git_version))
message(FATAL_ERROR
"project and git version are not compatible (project: '${PROJECT_VERSION}', git: '${full_version}'): "
"major and minor version are not equal !"
)
endif()
endif()
set(${OUTPUT_VERSION} "${full_version}" CACHE STRING "")
endif()
endfunction()
function(bc_make_package_source_target)
set(basename "")
string(TOLOWER "${CMAKE_PROJECT_NAME}" basename)
if (DEFINED BC_SPECFILE_NAME)
set(specfile_name "${BC_SPECFILE_NAME}")
else()
set(specfile_name "${basename}.spec")
endif()
set(specfile_target "${basename}-rpm-spec")
bc_generate_rpm_specfile("rpm/${specfile_name}.cmake" "rpm/${specfile_name}.cmake")
add_custom_target(${specfile_target}
COMMAND ${CMAKE_COMMAND}
"-DPROJECT_VERSION=${PROJECT_VERSION}"
"-DPROJECT_VERSION_MAJOR=${PROJECT_VERSION_MAJOR}"
"-DPROJECT_VERSION_MINOR=${PROJECT_VERSION_MINOR}"
"-DBCTOOLBOX_CMAKE_UTILS=${BCTOOLBOX_CMAKE_UTILS}"
"-DSRC=${CMAKE_CURRENT_BINARY_DIR}/rpm/${specfile_name}.cmake"
"-DDEST=${PROJECT_SOURCE_DIR}/${specfile_name}"
-P "${BCTOOLBOX_CMAKE_DIR}/ConfigureSpecfile.cmake"
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
BYPRODUCTS "${PROJECT_SOURCE_DIR}/${specfile_name}"
)
add_custom_target(package_source
COMMAND ${CMAKE_COMMAND}
"-DBCTOOLBOX_CMAKE_UTILS=${BCTOOLBOX_CMAKE_UTILS}"
"-DPROJECT_SOURCE_DIR=${PROJECT_SOURCE_DIR}"
"-DPROJECT_BINARY_DIR=${PROJECT_BINARY_DIR}"
"-DPROJECT_VERSION=${PROJECT_VERSION}"
"-DPROJECT_VERSION_MAJOR=${PROJECT_VERSION_MAJOR}"
"-DPROJECT_VERSION_MINOR=${PROJECT_VERSION_MINOR}"
"-DCPACK_PACKAGE_NAME=${CPACK_PACKAGE_NAME}"
"-DEXCLUDE_PATTERNS='${CPACK_SOURCE_IGNORE_FILES}'"
-P "${BCTOOLBOX_CMAKE_DIR}/MakeArchive.cmake"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
DEPENDS ${specfile_target}
)
endfunction()
bctoolbox-4.4.13/cmake/BcToolboxConfig.cmake.in 0000664 0000000 0000000 00000007370 13757173071 0021330 0 ustar 00root root 0000000 0000000 ############################################################################
# BcToolboxConfig.cmake
# Copyright (C) 2010-2019 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
#
# Config file for the bctoolbox package.
# Some components can be asked for: core, tester.
#
# It defines the following variables:
#
# BCTOOLBOX_FOUND - system has bctoolbox
# BCTOOLBOX_INCLUDE_DIRS - the bctoolbox include directory
# BCTOOLBOX_LIBRARIES - The libraries needed to use bctoolbox
# BCTOOLBOX_CPPFLAGS - The compilation flags needed to use bctoolbox
# BCTOOLBOX_LDFLAGS - The linking flags needed to use bctoolbox
# BCTOOLBOX_${comp}_FOUND - system has bctoolbox "comp" component
# BCTOOLBOX_${comp}_INCLUDE_DIRS - the bctoolbox "comp" component include directory
# BCTOOLBOX_${comp}_LIBRARIES - The libraries needed to use bctoolbox "comp" component
@PACKAGE_INIT@
include("${CMAKE_CURRENT_LIST_DIR}/bctoolboxTargets.cmake")
list(APPEND bctoolbox_FIND_COMPONENTS core)
if (ENABLE_TESTS_COMPONENT)
list(APPEND bctoolbox_FIND_COMPONENTS tester)
endif()
list(REMOVE_DUPLICATES bctoolbox_FIND_COMPONENTS)
set(bctoolbox_FIND_REQUIRED_core TRUE)
set(BCTOOLBOX_CPPFLAGS @BCTOOLBOX_CPPFLAGS@)
set(BCTOOLBOX_LDFLAGS "@LINK_FLAGS_STR@")
set(BCTOOLBOX_LIBRARIES )
foreach(comp ${bctoolbox_FIND_COMPONENTS})
string(TOUPPER ${comp} uppercomp)
if(comp STREQUAL "core")
set(targetname bctoolbox)
else()
set(targetname bctoolbox-${comp})
endif()
if(@ENABLE_SHARED@)
set(BCTOOLBOX_${uppercomp}_LIBRARIES ${targetname})
else()
set(targetname ${targetname}-static)
if(TARGET ${targetname})
if(LINPHONE_BUILDER_GROUP_EXTERNAL_SOURCE_PATH_BUILDERS)
set(BCTOOLBOX_${uppercomp}_LIBRARIES ${targetname})
else()
get_target_property(BCTOOLBOX_${uppercomp}_LIBRARIES ${targetname} LOCATION)
endif()
if(NOT BCTOOLBOX_${uppercomp}_LIBRARIES)
set(BCTOOLBOX_${uppercomp}_LIBRARIES)
endif()
get_target_property(BCTOOLBOX_${uppercomp}_LINK_LIBRARIES ${targetname} INTERFACE_LINK_LIBRARIES)
if(BCTOOLBOX_${uppercomp}_LINK_LIBRARIES)
list(APPEND BCTOOLBOX_${uppercomp}_LIBRARIES ${BCTOOLBOX_${uppercomp}_LINK_LIBRARIES})
endif()
endif()
endif()
if(TARGET ${targetname})
get_target_property(BCTOOLBOX_${uppercomp}_INCLUDE_DIRS ${targetname} INTERFACE_INCLUDE_DIRECTORIES)
if(NOT BCTOOLBOX_${uppercomp}_INCLUDE_DIRS)
set(BCTOOLBOX_${uppercomp}_INCLUDE_DIRS)
endif()
list(APPEND BCTOOLBOX_LIBRARIES ${BCTOOLBOX_${uppercomp}_LIBRARIES})
list(APPEND BCTOOLBOX_INCLUDE_DIRS ${BCTOOLBOX_${uppercomp}_INCLUDE_DIRS})
set(BCTOOLBOX_${uppercomp}_FOUND 1)
if(comp STREQUAL "core")
set(BCTOOLBOX_FOUND 1)
endif()
elseif(bctoolbox_FIND_REQUIRED_${comp})
message(FATAL_ERROR "Required bctoolbox component \"${comp}\" cannot be found")
endif()
endforeach()
set(BCTOOLBOX_CMAKE_DIR "${CMAKE_CURRENT_LIST_DIR}")
set(BCTOOLBOX_CMAKE_UTILS "${CMAKE_CURRENT_LIST_DIR}/bctoolboxCMakeUtils.cmake")
include("${BCTOOLBOX_CMAKE_UTILS}")
bctoolbox-4.4.13/cmake/ConfigureSpecfile.cmake 0000664 0000000 0000000 00000003073 13757173071 0021272 0 ustar 00root root 0000000 0000000 ############################################################################
# ConfigureSpecfile.cmake
# Copyright (C) 2010-2019 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
include("${BCTOOLBOX_CMAKE_UTILS}")
set(FULL_VERSION )
bc_compute_full_version(FULL_VERSION)
set(version_major )
set(version_minor )
set(version_patch )
set(identifiers )
set(metadata )
bc_parse_full_version("${FULL_VERSION}" version_major version_minor version_patch identifiers metadata)
set(RPM_VERSION ${version_major}.${version_minor}.${version_patch})
if (NOT identifiers)
set(RPM_RELEASE 1)
else()
string(SUBSTRING "${identifiers}" 1 -1 identifiers)
set(RPM_RELEASE "0.${identifiers}${metadata}")
endif()
configure_file("${SRC}" "${DEST}")
bctoolbox-4.4.13/cmake/FindDecaf.cmake 0000664 0000000 0000000 00000003104 13757173071 0017474 0 ustar 00root root 0000000 0000000 ############################################################################
# FindDecaf.txt
# Copyright (C) 2017 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
#
# - Find the decaf include files and library
#
# DECAF_FOUND - system has lib decaf
# DECAF_INCLUDE_DIRS - the decaf include directory
# DECAF_LIBRARY - The library needed to use decaf
include(CMakePushCheckState)
include(CheckIncludeFile)
find_path(DECAF_INCLUDE_DIRS
NAMES decaf.h
PATH_SUFFIXES include/decaf
)
# find the three mbedtls library
find_library(DECAF_LIBRARY
NAMES decaf
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Decaf
DEFAULT_MSG
DECAF_INCLUDE_DIRS DECAF_LIBRARY
)
mark_as_advanced(DECAF_INCLUDE_DIRS DECAF_LIBRARY)
bctoolbox-4.4.13/cmake/FindIconv.cmake 0000664 0000000 0000000 00000003431 13757173071 0017553 0 ustar 00root root 0000000 0000000 ############################################################################
# FindIconv.cmake
# Copyright (C) 2014 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
#
# - Find the iconv include file and library
#
# ICONV_FOUND - system has libiconv
# ICONV_INCLUDE_DIRS - the libiconv include directory
# ICONV_LIBRARIES - The libraries needed to use libiconv
if(APPLE AND NOT IOS)
set(ICONV_HINTS "${CMAKE_OSX_SYSROOT}/usr" "/usr")
endif()
if(ICONV_HINTS)
set(ICONV_LIBRARIES_HINTS "${ICONV_HINTS}/lib")
endif()
find_path(ICONV_INCLUDE_DIRS
NAMES iconv.h
HINTS "${ICONV_HINTS}"
PATH_SUFFIXES include
)
if(ICONV_INCLUDE_DIRS)
set(HAVE_ICONV_H 1)
endif()
find_library(ICONV_LIBRARIES
NAMES iconv
HINTS "${ICONV_LIBRARIES_HINTS}"
)
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Iconv
DEFAULT_MSG
ICONV_INCLUDE_DIRS ICONV_LIBRARIES HAVE_ICONV_H
)
mark_as_advanced(ICONV_INCLUDE_DIRS ICONV_LIBRARIES HAVE_ICONV_H)
bctoolbox-4.4.13/cmake/FindMbedTLS.cmake 0000664 0000000 0000000 00000005434 13757173071 0017734 0 ustar 00root root 0000000 0000000 ############################################################################
# FindMdebTLS.txt
# Copyright (C) 2015 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
#
# - Find the mbedTLS include file and library
#
# MBEDTLS_FOUND - system has mbedTLS
# MBEDTLS_INCLUDE_DIRS - the mbedTLS include directory
# MBEDTLS_LIBRARIES - The libraries needed to use mbedTLS
include(CMakePushCheckState)
include(CheckIncludeFile)
include(CheckCSourceCompiles)
include(CheckSymbolExists)
find_path(MBEDTLS_INCLUDE_DIRS
NAMES mbedtls/ssl.h
PATH_SUFFIXES include
)
# find the three mbedtls library
find_library(MBEDTLS_LIBRARY
NAMES mbedtls
)
find_library(MBEDX509_LIBRARY
NAMES mbedx509
)
find_library(MBEDCRYPTO_LIBRARY
NAMES mbedcrypto
)
cmake_push_check_state(RESET)
set(CMAKE_REQUIRED_INCLUDES ${MBEDTLS_INCLUDE_DIRS} ${CMAKE_REQUIRED_INCLUDES_${BUILD_TYPE}})
list(APPEND CMAKE_REQUIRED_LIBRARIES ${MBEDTLS_LIBRARY} ${MBEDX509_LIBRARY} ${MBEDCRYPTO_LIBRARY})
# check we have a mbedTLS version 2 or above(all functions are prefixed mbedtls_)
if(MBEDTLS_LIBRARY AND MBEDX509_LIBRARY AND MBEDCRYPTO_LIBRARY)
check_symbol_exists(mbedtls_ssl_init "mbedtls/ssl.h" MBEDTLS_V2)
if(MBEDTLS_V2)
set (MBEDTLS_LIBRARIES
${MBEDTLS_LIBRARY}
${MBEDX509_LIBRARY}
${MBEDCRYPTO_LIBRARY}
)
else()
message ("MESSAGE: NO MBEDTLS_V2")
message ("MESSAGE: MBEDTLS_LIBRARY=" ${MBEDTLS_LIBRARY})
message ("MESSAGE: MBEDX509_LIBRARY=" ${MBEDX509_LIBRARY})
message ("MESSAGE: MBEDCRYPTO_LIBRARY=" ${MBEDCRYPTO_LIBRARY})
endif()
endif()
if(MBEDTLS_LIBRARIES)
check_symbol_exists(mbedtls_ssl_get_dtls_srtp_protection_profile "mbedtls/ssl.h" HAVE_SSL_GET_DTLS_SRTP_PROTECTION_PROFILE)
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(MbedTLS
DEFAULT_MSG
MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARIES
)
cmake_pop_check_state()
mark_as_advanced(MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARIES HAVE_SSL_GET_DTLS_SRTP_PROTECTION_PROFILE)
bctoolbox-4.4.13/cmake/FindPolarSSL.cmake 0000664 0000000 0000000 00000004511 13757173071 0020134 0 ustar 00root root 0000000 0000000 ############################################################################
# FindPolarSSL.txt
# Copyright (C) 2015 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
#
# - Find the polarssl include file and library
#
# POLARSSL_FOUND - system has polarssl
# POLARSSL_INCLUDE_DIRS - the polarssl include directory
# POLARSSL_LIBRARIES - The libraries needed to use polarssl
include(CMakePushCheckState)
include(CheckIncludeFile)
include(CheckCSourceCompiles)
include(CheckSymbolExists)
find_path(POLARSSL_INCLUDE_DIRS
NAMES polarssl/ssl.h
PATH_SUFFIXES include
)
if(POLARSSL_INCLUDE_DIRS)
set(HAVE_POLARSSL_SSL_H 1)
endif()
find_library(POLARSSL_LIBRARIES
NAMES polarssl mbedtls
PATH_SUFFIXES bin lib
)
if(POLARSSL_LIBRARIES)
#x509parse_crtpath is present in polarssl1.3 but not 1.2, use it to check what version is present
cmake_push_check_state(RESET)
set(CMAKE_REQUIRED_INCLUDES ${POLARSSL_INCLUDE_DIRS})
set(CMAKE_REQUIRED_LIBRARIES ${POLARSSL_LIBRARIES})
check_symbol_exists(ssl_get_dtls_srtp_protection_profile "polarssl/ssl.h" HAVE_SSL_GET_DTLS_SRTP_PROTECTION_PROFILE)
check_symbol_exists(ctr_drbg_free "polarssl/ctr_drbg.h" CTR_DRBG_FREE)
cmake_pop_check_state()
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(PolarSSL
DEFAULT_MSG
POLARSSL_INCLUDE_DIRS POLARSSL_LIBRARIES HAVE_POLARSSL_SSL_H
)
mark_as_advanced(POLARSSL_INCLUDE_DIRS POLARSSL_LIBRARIES HAVE_POLARSSL_SSL_H POLARSSL_VERSION13_OK CTR_DRGB_FREE HAVE_SSL_GET_DTLS_SRTP_PROTECTION_PROFILE)
bctoolbox-4.4.13/cmake/MakeArchive.cmake 0000664 0000000 0000000 00000002744 13757173071 0020061 0 ustar 00root root 0000000 0000000 ############################################################################
# MakeArchive.cmake
# Copyright (C) 2010-2019 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
include("${BCTOOLBOX_CMAKE_UTILS}")
bc_compute_full_version(version)
set(archive_name "${CPACK_PACKAGE_NAME}-${version}")
set(archive_path "${PROJECT_BINARY_DIR}/${archive_name}.tar.gz")
find_program(TAR tar)
set(EXCLUDE_ARGS )
foreach (pattern ${EXCLUDE_PATTERNS})
list(APPEND EXCLUDE_ARGS "--exclude=${pattern}")
endforeach()
execute_process(COMMAND ${TAR} -C "${PROJECT_SOURCE_DIR}" -cz -f "${archive_path}" "--transform" "s,^\\.,${archive_name}," ${EXCLUDE_ARGS} .)
bctoolbox-4.4.13/cmake/gitversion.h.in 0000664 0000000 0000000 00000001464 13757173071 0017645 0 ustar 00root root 0000000 0000000 /*
linphone
Copyright (C) 2010-2017 Belledonne Communications SARL
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 2
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.
*/
#define @PREFIX_GIT_VERSION@_GIT_VERSION "@PROJECT_GIT_VERSION@" bctoolbox-4.4.13/config.h.cmake 0000664 0000000 0000000 00000002520 13757173071 0016305 0 ustar 00root root 0000000 0000000 /***************************************************************************
* config.h.cmake
* Copyright (C) 2014 Belledonne Communications, Grenoble France
*
****************************************************************************
*
* 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 2
* 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.
*
****************************************************************************/
#cmakedefine HAVE_DTLS_SRTP 1
#cmakedefine HAVE_DECAF 1
#cmakedefine HAVE_MBEDTLS 1
#cmakedefine HAVE_POLARSSL 1
#cmakedefine HAVE_CTR_DRGB_FREE 1
#cmakedefine HAVE_CU_GET_SUITE 1
#cmakedefine HAVE_CU_CURSES 1
#cmakedefine HAVE_CU_SET_TRACE_HANDLER 1
#cmakedefine HAVE_LIBRT 1
#cmakedefine BCTBX_STATIC
#cmakedefine HAVE_EXECINFO
bctoolbox-4.4.13/include/ 0000775 0000000 0000000 00000000000 13757173071 0015234 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/include/CMakeLists.txt 0000664 0000000 0000000 00000003344 13757173071 0020000 0 ustar 00root root 0000000 0000000 ############################################################################
# CMakeLists.txt
# Copyright (C) 2016 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
set(HEADER_FILES
charconv.h
compiler.h
defs.h
exception.hh
list.h
logging.h
map.h
parser.h
port.h
regex.h
vconnect.h
vfs.h
)
if(APPLE)
list(APPEND HEADER_FILES ios_utils.hh)
endif()
if(MBEDTLS_FOUND OR POLARSSL_FOUND)
list(APPEND HEADER_FILES crypto.h)
endif()
if(ENABLE_TESTS_COMPONENT)
list(APPEND HEADER_FILES tester.h)
endif()
set(BCTOOLBOX_HEADER_FILES )
foreach(HEADER_FILE ${HEADER_FILES})
list(APPEND BCTOOLBOX_HEADER_FILES "${CMAKE_CURRENT_LIST_DIR}/bctoolbox/${HEADER_FILE}")
endforeach()
set(BCTOOLBOX_HEADER_FILES ${BCTOOLBOX_HEADER_FILES} PARENT_SCOPE)
install(FILES ${BCTOOLBOX_HEADER_FILES}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/bctoolbox
PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
)
bctoolbox-4.4.13/include/bctoolbox/ 0000775 0000000 0000000 00000000000 13757173071 0017227 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/include/bctoolbox/charconv.h 0000664 0000000 0000000 00000004704 13757173071 0021210 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_CHARCONV_H
#define BCTBX_CHARCONV_H
#include "bctoolbox/port.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @brief Set the default encoding for the application.
*
* @param[in] encoding default encoding, "locale" to set it to the system's locale
*/
BCTBX_PUBLIC void bctbx_set_default_encoding (const char *encoding);
/**
* @brief Return the default encoding for the application.
*
* @return a pointer to a null-terminated string containing the default encoding.
*/
BCTBX_PUBLIC const char *bctbx_get_default_encoding ();
/**
* @brief Convert the given string from system locale to UTF8.
*
* @param[in] str string to convert
*
* @return a pointer to a null-terminated string containing the converted string. This buffer must then be freed
* by caller. NULL on failure.
*/
BCTBX_PUBLIC char *bctbx_locale_to_utf8 (const char *str);
/**
* @brief Convert the given string from UTF8 to system locale.
*
* @param[in] str string to convert
*
* @return a pointer to a null-terminated string containing the converted string. This buffer must then be freed
* by caller. NULL on failure.
*/
BCTBX_PUBLIC char *bctbx_utf8_to_locale (const char *str);
/**
* @brief Convert the given string.
*
* @param[in] str string to convert
* @param[in] encoding charset of the string
*
* @return a pointer to a null-terminated string containing the converted string. This buffer must then be freed
* by caller. NULL on failure.
*
* @note If encoding is equal to "locale" then it will use the system's locale
* @note If encoding is UTF-8 then it returns a copy of str
*/
BCTBX_PUBLIC char *bctbx_convert_any_to_utf8 (const char *str, const char *encoding);
#ifdef __cplusplus
}
#endif
#endif /* BCTBX_CHARCONV_H */
bctoolbox-4.4.13/include/bctoolbox/compiler.h 0000664 0000000 0000000 00000003131 13757173071 0021210 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef COMPILER_H
#define COMPILER_H
#ifdef __has_feature
#if __has_feature(address_sanitizer)
#define BCTBX_ASAN_ENABLED
#endif // if __has_feature(address_sanitizer)
#elif defined(__SANITIZE_ADDRESS__)
#define BCTBX_ASAN_ENABLED
#endif // ifdef __has_feature
#ifdef BCTBX_ASAN_ENABLED
#define BCTBX_DISABLE_ASAN __attribute__((no_sanitize_address))
#else
#define BCTBX_DISABLE_ASAN
#endif // ifdef BCTBX_ASAN_ENABLED
#ifdef __has_attribute
#if __has_attribute(no_sanitize)
#define BCTBX_DISABLE_UBSAN __attribute__((no_sanitize("undefined")))
#else
#define BCTBX_DISABLE_UBSAN
#endif // __has_attribute(no_sanitize)
#elif defined(__GNUC__) && !defined(__MINGW32__) && GCC_VERSION >= 40900
#define BCTBX_DISABLE_UBSAN __attribute__((no_sanitize_undefined))
#else
#define BCTBX_DISABLE_UBSAN
#endif // ifdef __has_attribute
#endif // ifdef COMPILER_H
bctoolbox-4.4.13/include/bctoolbox/crypto.h 0000664 0000000 0000000 00000150730 13757173071 0020726 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_CRYPTO_H
#define BCTBX_CRYPTO_H
#include "bctoolbox/port.h"
#include "bctoolbox/list.h"
/* key agreements settings defines */
/* Each algo is defined as a bit toggled in a 32 bits integer,
* so we can easily ask for all availables ones
*/
#define BCTBX_DHM_UNSET 0x00000000
#define BCTBX_DHM_2048 0x00000001
#define BCTBX_DHM_3072 0x00000002
#define BCTBX_ECDH_X25519 0x00000004
#define BCTBX_ECDH_X448 0x00000008
/* EdDSA defines */
#define BCTBX_EDDSA_UNSET 0
#define BCTBX_EDDSA_25519 1
#define BCTBX_EDDSA_448 2
#define BCTBX_VERIFY_SUCCESS 0
#define BCTBX_VERIFY_FAILED -1
/* Elliptic Curves Key lengths defines:
theses are redefines of the values defined in decaf headers made available to bctoolbox library users
bctoolbox will fail to compile if these values are not in sync with the decaf ones */
#define BCTBX_ECDH_X25519_PUBLIC_SIZE 32
#define BCTBX_ECDH_X25519_PRIVATE_SIZE BCTBX_ECDH_X25519_PUBLIC_SIZE
#define BCTBX_ECDH_X448_PUBLIC_SIZE 56
#define BCTBX_ECDH_X448_PRIVATE_SIZE BCTBX_ECDH_X448_PUBLIC_SIZE
#define BCTBX_EDDSA_25519_PUBLIC_SIZE 32
#define BCTBX_EDDSA_25519_PRIVATE_SIZE BCTBX_EDDSA_25519_PUBLIC_SIZE
#define BCTBX_EDDSA_25519_SIGNATURE_SIZE (BCTBX_EDDSA_25519_PUBLIC_SIZE + BCTBX_EDDSA_25519_PRIVATE_SIZE)
#define BCTBX_EDDSA_448_PUBLIC_SIZE 57
#define BCTBX_EDDSA_448_PRIVATE_SIZE BCTBX_EDDSA_448_PUBLIC_SIZE
#define BCTBX_EDDSA_448_SIGNATURE_SIZE (BCTBX_EDDSA_448_PUBLIC_SIZE + BCTBX_EDDSA_448_PRIVATE_SIZE)
/* SSL settings defines */
#define BCTBX_SSL_UNSET -1
#define BCTBX_SSL_IS_CLIENT 0
#define BCTBX_SSL_IS_SERVER 1
#define BCTBX_SSL_TRANSPORT_STREAM 0
#define BCTBX_SSL_TRANSPORT_DATAGRAM 1
#define BCTBX_SSL_VERIFY_NONE 0
#define BCTBX_SSL_VERIFY_OPTIONAL 1
#define BCTBX_SSL_VERIFY_REQUIRED 2
/* Encryption/decryption defines */
#define BCTBX_GCM_ENCRYPT 1
#define BCTBX_GCM_DECRYPT 0
/* Error codes : All error codes are negative and defined on 32 bits on format -0x7XXXXXXX
* in order to be sure to not overlap on crypto librairy (polarssl or mbedtls for now) which are defined on 16 bits 0x[7-0]XXX */
#define BCTBX_ERROR_UNSPECIFIED_ERROR -0x70000000
#define BCTBX_ERROR_OUTPUT_BUFFER_TOO_SMALL -0x70001000
#define BCTBX_ERROR_INVALID_BASE64_INPUT -0x70002000
#define BCTBX_ERROR_INVALID_INPUT_DATA -0x70004000
#define BCTBX_ERROR_UNAVAILABLE_FUNCTION -0x70008000
/* key related */
#define BCTBX_ERROR_UNABLE_TO_PARSE_KEY -0x70010000
/* Certificate related */
#define BCTBX_ERROR_INVALID_CERTIFICATE -0x70020000
#define BCTBX_ERROR_CERTIFICATE_GENERATION_FAIL -0x70020001
#define BCTBX_ERROR_CERTIFICATE_WRITE_PEM -0x70020002
#define BCTBX_ERROR_CERTIFICATE_PARSE_PEM -0x70020004
#define BCTBX_ERROR_UNSUPPORTED_HASH_FUNCTION -0x70020008
/* SSL related */
#define BCTBX_ERROR_INVALID_SSL_CONFIG -0x70030001
#define BCTBX_ERROR_INVALID_SSL_TRANSPORT -0x70030002
#define BCTBX_ERROR_INVALID_SSL_ENDPOINT -0x70030004
#define BCTBX_ERROR_INVALID_SSL_AUTHMODE -0x70030008
#define BCTBX_ERROR_INVALID_SSL_CONTEXT -0x70030010
#define BCTBX_ERROR_NET_WANT_READ -0x70032000
#define BCTBX_ERROR_NET_WANT_WRITE -0x70034000
#define BCTBX_ERROR_SSL_PEER_CLOSE_NOTIFY -0x70038000
#define BCTBX_ERROR_NET_CONN_RESET -0x70030000
/* Symmetric ciphers related */
#define BCTBX_ERROR_AUTHENTICATION_FAILED -0x70040000
/* certificate verification flags codes */
#define BCTBX_CERTIFICATE_VERIFY_ALL_FLAGS 0xFFFFFFFF
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_EXPIRED 0x01 /**< The certificate validity has expired. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_REVOKED 0x02 /**< The certificate has been revoked (is on a CRL). */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_CN_MISMATCH 0x04 /**< The certificate Common Name (CN) does not match with the expected CN. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_NOT_TRUSTED 0x08 /**< The certificate is not correctly signed by the trusted CA. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_MISSING 0x10 /**< Certificate was missing. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_SKIP_VERIFY 0x20 /**< Certificate verification was skipped. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_OTHER 0x0100 /**< Other reason (can be used by verify callback) */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_FUTURE 0x0200 /**< The certificate validity starts in the future. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_KEY_USAGE 0x0400 /**< Usage does not match the keyUsage extension. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_EXT_KEY_USAGE 0x0800 /**< Usage does not match the extendedKeyUsage extension. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_NS_CERT_TYPE 0x1000 /**< Usage does not match the nsCertType extension. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_BAD_MD 0x2000 /**< The certificate is signed with an unacceptable hash. */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_BAD_PK 0x4000 /**< The certificate is signed with an unacceptable PK alg (eg RSA vs ECDSA). */
#define BCTBX_CERTIFICATE_VERIFY_BADCERT_BAD_KEY 0x8000 /**< The certificate is signed with an unacceptable key (eg bad curve, RSA too short). */
#define BCTBX_CERTIFICATE_VERIFY_BADCRL_FUTURE 0x10000 /**< The CRL is from the future */
#define BCTBX_CERTIFICATE_VERIFY_BADCRL_NOT_TRUSTED 0x20000 /**< CRL is not correctly signed by the trusted CA. */
#define BCTBX_CERTIFICATE_VERIFY_BADCRL_EXPIRED 0x40000 /**< CRL is expired. */
#define BCTBX_CERTIFICATE_VERIFY_BADCRL_BAD_MD 0x80000 /**< The CRL is signed with an unacceptable hash. */
#define BCTBX_CERTIFICATE_VERIFY_BADCRL_BAD_PK 0x100000 /**< The CRL is signed with an unacceptable PK alg (eg RSA vs ECDSA). */
#define BCTBX_CERTIFICATE_VERIFY_BADCRL_BAD_KEY 0x200000 /**< The CRL is signed with an unacceptable key (eg bad curve, RSA too short). */
/* Hash functions type */
typedef enum bctbx_md_type {
BCTBX_MD_UNDEFINED,
BCTBX_MD_SHA1,
BCTBX_MD_SHA224,
BCTBX_MD_SHA256,
BCTBX_MD_SHA384,
BCTBX_MD_SHA512} bctbx_md_type_t;
/* Dtls srtp protection profile */
typedef enum bctbx_srtp_profile {
BCTBX_SRTP_UNDEFINED,
BCTBX_SRTP_AES128_CM_HMAC_SHA1_80,
BCTBX_SRTP_AES128_CM_HMAC_SHA1_32,
BCTBX_SRTP_NULL_HMAC_SHA1_80,
BCTBX_SRTP_NULL_HMAC_SHA1_32
} bctbx_dtls_srtp_profile_t;
typedef enum bctbx_type_implementation {
BCTBX_POLARSSL,
BCTBX_POLARSSL1_2,
BCTBX_MBEDTLS
} bctbx_type_implementation_t;
#ifdef __cplusplus
extern "C"{
#endif
/*****************************************************************************/
/****** Utils ******/
/*****************************************************************************/
/**
* @brief Return a string translation of an error code
* PolarSSL and mbedTLS error codes are on 16 bits always negatives, and these are forwarded to the crypto library error to string translation
* Specific bctoolbox error code are on 32 bits, all in the form -0x7XXX XXXX
* Output string is truncated if the buffer is too small and always include a null termination char
*
* @param[in] error_code The error code
* @param[in/out] buffer Buffer to place error string representation
* @param[in] buffer_length Size of the buffer in bytes.
*/
BCTBX_PUBLIC void bctbx_strerror(int32_t error_code, char *buffer, size_t buffer_length);
/**
* @brief Encode a buffer into base64 format
* @param[out] output base64 encoded buffer
* @param[in/out] output_length output buffer max size and actual size of buffer after encoding
* @param[in] input source plain buffer
* @param[in] input_length Length in bytes of plain buffer to be encoded
*
* @return 0 if success or BCTBX_ERROR_OUTPUT_BUFFER_TOO_SMALL if the output buffer cannot contain the encoded data
*
* @note If the function is called with *output_length=0, set the requested buffer size in output_length
*/
BCTBX_PUBLIC int32_t bctbx_base64_encode(unsigned char *output, size_t *output_length, const unsigned char *input, size_t input_length);
/**
* @brief Decode a base64 formatted buffer.
* @param[out] output plain buffer
* @param[in/out] output_length output buffer max size and actual size of buffer after decoding
* @param[in] input source base64 encoded buffer
* @param[in] input_length Length in bytes of base64 buffer to be decoded
*
* @return 0 if success, BCTBX_ERROR_OUTPUT_BUFFER_TOO_SMALL if the output buffer cannot contain the decoded data
* or BCTBX_ERROR_INVALID_BASE64_INPUT if encoded buffer was incorrect base64 data
*
* @note If the function is called with *output_length=0, set the requested buffer size in output_length
*/
BCTBX_PUBLIC int32_t bctbx_base64_decode(unsigned char *output, size_t *output_length, const unsigned char *input, size_t input_length);
/*****************************************************************************/
/****** Random Number Generation ******/
/*****************************************************************************/
/** @brief An opaque structure used to store RNG context
* Instanciate pointers only and allocate them using the bctbx_rng_context_new() function
*/
typedef struct bctbx_rng_context_struct bctbx_rng_context_t;
/**
* @brief Create and initialise the Random Number Generator context
* @return a pointer to the RNG context
*/
BCTBX_PUBLIC bctbx_rng_context_t *bctbx_rng_context_new(void);
/**
* @brief Get some random material
*
* @param[in/out] context The RNG context to be used
* @param[out] output A destination buffer for the random material generated
* @param[in] output_length Size in bytes of the output buffer and requested random material
*
* @return 0 on success
*/
BCTBX_PUBLIC int32_t bctbx_rng_get(bctbx_rng_context_t *context, unsigned char*output, size_t output_length);
/**
* @brief Clear the RNG context and free internal buffer
*
* @param[in] context The RNG context to clear
*/
BCTBX_PUBLIC void bctbx_rng_context_free(bctbx_rng_context_t *context);
/*****************************************************************************/
/***** Signing key *****/
/*****************************************************************************/
/** @brief An opaque structure used to store the signing key context
* Instanciate pointers only and allocate them using the bctbx_signing_key_new() function
*/
typedef struct bctbx_signing_key_struct bctbx_signing_key_t;
/**
* @brief Create and initialise a signing key context
* @return a pointer to the signing key context
*/
BCTBX_PUBLIC bctbx_signing_key_t *bctbx_signing_key_new(void);
/**
* @brief Clear the signing key context and free internal buffer
*
* @param[in] key The signing key context to clear
*/
BCTBX_PUBLIC void bctbx_signing_key_free(bctbx_signing_key_t *key);
/**
* @brief Write the key in a buffer as a PEM string
*
* @param[in] key The signing key to be extracted in PEM format
*
* @return a pointer to a null terminated string containing the key in PEM format. This buffer must then be freed by caller. NULL on failure.
*/
BCTBX_PUBLIC char *bctbx_signing_key_get_pem(bctbx_signing_key_t *key);
/**
* @brief Parse signing key in PEM format from a null terminated string buffer
*
* @param[in/out] key An already initialised signing key context
* @param[in] buffer The input buffer containing a PEM format key in a null terminated string
* @param[in] buffer_length The length of input buffer, including the NULL termination char
* @param[in] password Password for decryption(may be NULL)
* @param[in] passzord_length size of password
*
* @return 0 on success
*/
BCTBX_PUBLIC int32_t bctbx_signing_key_parse(bctbx_signing_key_t *key, const char *buffer, size_t buffer_length, const unsigned char *password, size_t password_length);
/**
* @brief Parse signing key from a file
*
* @param[in/out] key An already initialised signing key context
* @param[in] path filename to read the key from
* @param[in] password Password for decryption(may be NULL)
*
* @return 0 on success
*/
BCTBX_PUBLIC int32_t bctbx_signing_key_parse_file(bctbx_signing_key_t *key, const char *path, const char *password);
/*****************************************************************************/
/***** X509 Certificate *****/
/*****************************************************************************/
/** @brief An opaque structure used to store the certificate context
* Instanciate pointers only and allocate them using the bctbx_x509_certificate_new() function
*/
typedef struct bctbx_x509_certificate_struct bctbx_x509_certificate_t;
/**
* @brief Create and initialise a x509 certificate context
* @return a pointer to the certificate context
*/
BCTBX_PUBLIC bctbx_x509_certificate_t *bctbx_x509_certificate_new(void);
/**
* @brief Clear the certificate context and free internal buffer
*
* @param[in] cert The x509 certificate context to clear
*/
BCTBX_PUBLIC void bctbx_x509_certificate_free(bctbx_x509_certificate_t *cert);
/**
* @brief Write the certificate in a buffer as a PEM string
*
* @param[in] cert The certificate to be extracted in PEM format
*
* @return a pointer to a null terminated string containing the certificate in PEM format. This buffer must then be freed by caller. NULL on failure.
*/
BCTBX_PUBLIC char *bctbx_x509_certificates_chain_get_pem(bctbx_x509_certificate_t *cert);
/**
* @brief Return an informational string about the certificate
*
* @param[out] buf Buffer to receive the output
* @param[in] size Maximum output buffer size
* @param[in] prefix A line prefix
* @param[in] cert The x509 certificate
*
* @return The length of the string written or a negative error code
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_get_info_string(char *buf, size_t size, const char *prefix, const bctbx_x509_certificate_t *cert);
/**
* @brief Parse an x509 certificate in PEM format from a null terminated string buffer
*
* @param[in/out] cert An already initialised x509 certificate context
* @param[in] buffer The input buffer containing a PEM format certificate in a null terminated string
* @param[in] buffer_length The length of input buffer, including the NULL termination char
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_parse(bctbx_x509_certificate_t *cert, const char *buffer, size_t buffer_length);
/**
* @brief Load one or more certificates and add them to the chained list
*
* @param[in/out] cert points to the start of the chain, can be an empty initialised certificate context
* @param[in] path filename to read the certificate from
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_parse_file(bctbx_x509_certificate_t *cert, const char *path);
/**
* @brief Load one or more certificates files from a path and add them to the chained list
*
* @param[in/out] cert points to the start of the chain, can be an empty initialised certificate context
* @param[in] path directory to read certicates files from
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_parse_path(bctbx_x509_certificate_t *cert, const char *path);
/**
* @brief Get the length in bytes of a certifcate chain in DER format
*
* @param[in] cert The certificate chain
*
* @return The length in bytes of the certificate buffer in DER format, 0 if no certificate found
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_get_der_length(bctbx_x509_certificate_t *cert);
/**
* @brief Get the certificate in DER format in a null terminated string
*
* @param[in] cert The certificate chain
* @param[in/out] buffer The buffer to hold the certificate
* @param[in] buffer_length Maximum output buffer size
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_get_der(bctbx_x509_certificate_t *cert, unsigned char *buffer, size_t buffer_length);
/**
* @brief Store the certificate subject DN in printable form into buf
*
* @param[in] cert The x509 certificate
* @param[in/out] dn A buffer to store the DN string
* @param[in] dn_length Maximum size to be written in buffer
*
* @return The length of the string written (not including the terminated nul byte), or a negative error code
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_get_subject_dn(const bctbx_x509_certificate_t *cert, char *dn, size_t dn_length);
/**
* @brief Obtain the certificate subjects (all subjectAltName URIS and DNS + subject CN)
*
* @param[in] cert The x509 certificate
* @return a list of allocated strings (char*), to be freed with bctbx_free()
*/
BCTBX_PUBLIC bctbx_list_t *bctbx_x509_certificate_get_subjects(const bctbx_x509_certificate_t *cert);
/**
* @brief Generate certificate fingerprint (hash of the DER format certificate) hexadecimal format in a null terminated string
*
* @param[in] cert The x509 certificate
* @param[in/out] fingerprint The buffer to hold the fingerprint(null terminated string in hexadecimal)
* @param[in] fingerprint_length Maximum length of the fingerprint buffer
* @param[in] hash_algorithm set to BCTBX_MD_UNDEFINED to use the hash used in certificate signature(recommended)
* or specify an other hash algorithm(BCTBX_MD_SHA1, BCTBX_MD_SHA224, BCTBX_MD_SHA256, BCTBX_MD_SHA384, BCTBX_MD_SHA512)
* @return length of written on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_get_fingerprint(const bctbx_x509_certificate_t *cert, char *fingerprint, size_t fingerprint_length, bctbx_md_type_t hash_algorithm);
/**
* @brief Retrieve the certificate signature hash function
*
* @param[in] cert The x509 certificate
* @param[out] hash_algorithm The hash algorithm used for the certificate signature or BCTBX_MD_UNDEFINED if unable to retrieve it
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_get_signature_hash_function(const bctbx_x509_certificate_t *certificate, bctbx_md_type_t *hash_algorithm);
/**
* @brief Generate a self-signed certificate using RSA 3072 bits signature algorithm
*
* @param[in] subject The certificate subject
* @param[in/out] certificate An empty intialised certificate pointer to hold the generated certificate
* @param[in/out] pkey An empty initialised signing key pointer to hold the key generated and used to sign the certificate (RSA 3072 bits)
* @param[out] pem If not null, a buffer to hold a PEM string of the certificate and key
* @param[in] pem_length pem buffer length
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_generate_selfsigned(const char *subject, bctbx_x509_certificate_t *certificate, bctbx_signing_key_t *pkey, char *pem, size_t pem_length);
/**
* @brief Convert underlying crypto library certificate flags into a printable string
*
* @param[out] buffer a buffer to hold the output string
* @param[in] buffer_size maximum buffer size
* @param[in] flags The flags from the underlying crypto library, provided in callback functions
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_flags_to_string(char *buffer, size_t buffer_size, uint32_t flags);
/**
* @brief Set a certificate flags (using underlying crypto library defines)
*
* @param[in/out] flags The certificate flags holder directly provided by crypto library in a callback function
* @param[in] flags_to_set Flags to be set, bctoolbox defines
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_set_flag(uint32_t *flags, uint32_t flags_to_set);
/**
* @brief convert certificate flags from underlying crypto library defines to bctoolbox ones
*
* @param[in] flags certificate flags provided by the crypto library in a callback function
*
* @return same flag but using the bctoolbox API definitions
*/
BCTBX_PUBLIC uint32_t bctbx_x509_certificate_remap_flag(uint32_t flags);
/**
* @brief Unset a certificate flags (using underlying crypto library defines)
*
* @param[in/out] flags The certificate flags holder directly provided by crypto library in a callback function
* @param[in] flags_to_set Flags to be unset, bctoolbox defines
*
* @return 0 on success, negative error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_x509_certificate_unset_flag(uint32_t *flags, uint32_t flags_to_unset);
/*****************************************************************************/
/***** SSL *****/
/*****************************************************************************/
typedef struct bctbx_ssl_context_struct bctbx_ssl_context_t;
typedef struct bctbx_ssl_config_struct bctbx_ssl_config_t;
BCTBX_PUBLIC bctbx_type_implementation_t bctbx_ssl_get_implementation_type(void);
BCTBX_PUBLIC bctbx_ssl_context_t *bctbx_ssl_context_new(void);
BCTBX_PUBLIC void bctbx_ssl_context_free(bctbx_ssl_context_t *ssl_ctx);
BCTBX_PUBLIC int32_t bctbx_ssl_context_setup(bctbx_ssl_context_t *ssl_ctx, bctbx_ssl_config_t *ssl_config);
BCTBX_PUBLIC int32_t bctbx_ssl_close_notify(bctbx_ssl_context_t *ssl_ctx);
BCTBX_PUBLIC int32_t bctbx_ssl_session_reset(bctbx_ssl_context_t *ssl_ctx);
BCTBX_PUBLIC int32_t bctbx_ssl_read(bctbx_ssl_context_t *ssl_ctx, unsigned char *buf, size_t buf_length);
BCTBX_PUBLIC int32_t bctbx_ssl_write(bctbx_ssl_context_t *ssl_ctx, const unsigned char *buf, size_t buf_length);
BCTBX_PUBLIC int32_t bctbx_ssl_set_hostname(bctbx_ssl_context_t *ssl_ctx, const char *hostname);
BCTBX_PUBLIC int32_t bctbx_ssl_handshake(bctbx_ssl_context_t *ssl_ctx);
BCTBX_PUBLIC int32_t bctbx_ssl_set_hs_own_cert(bctbx_ssl_context_t *ssl_ctx, bctbx_x509_certificate_t *cert, bctbx_signing_key_t *key);
BCTBX_PUBLIC void bctbx_ssl_set_io_callbacks(bctbx_ssl_context_t *ssl_ctx, void *callback_data,
int(*callback_send_function)(void *, const unsigned char *, size_t), /* callbacks args are: callback data, data buffer to be send, size of data buffer */
int(*callback_recv_function)(void *, unsigned char *, size_t)); /* args: callback data, data buffer to be read, size of data buffer */
BCTBX_PUBLIC const bctbx_x509_certificate_t *bctbx_ssl_get_peer_certificate(bctbx_ssl_context_t *ssl_ctx);
BCTBX_PUBLIC const char *bctbx_ssl_get_ciphersuite(bctbx_ssl_context_t *ssl_ctx);
BCTBX_PUBLIC int bctbx_ssl_get_ciphersuite_id(const char* ciphersuite);
BCTBX_PUBLIC const char *bctbx_ssl_get_version(bctbx_ssl_context_t *ssl_ctx);
BCTBX_PUBLIC bctbx_ssl_config_t *bctbx_ssl_config_new(void);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_crypto_library_config(bctbx_ssl_config_t *ssl_config, void *internal_config);
BCTBX_PUBLIC void bctbx_ssl_config_free(bctbx_ssl_config_t *ssl_config);
BCTBX_PUBLIC void *bctbx_ssl_config_get_private_config(bctbx_ssl_config_t *ssl_config);
BCTBX_PUBLIC int32_t bctbx_ssl_config_defaults(bctbx_ssl_config_t *ssl_config, int endpoint, int transport);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_endpoint(bctbx_ssl_config_t *ssl_config, int endpoint);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_transport (bctbx_ssl_config_t *ssl_config, int transport);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_authmode(bctbx_ssl_config_t *ssl_config, int authmode);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_rng(bctbx_ssl_config_t *ssl_config, int(*rng_function)(void *, unsigned char *, size_t), void *rng_context);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_callback_verify(bctbx_ssl_config_t *ssl_config, int(*callback_function)(void *, bctbx_x509_certificate_t *, int, uint32_t *), void *callback_data);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_callback_cli_cert(bctbx_ssl_config_t *ssl_config, int(*callback_function)(void *, bctbx_ssl_context_t *, unsigned char *, size_t), void *callback_data);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_ca_chain(bctbx_ssl_config_t *ssl_config, bctbx_x509_certificate_t *ca_chain);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_own_cert(bctbx_ssl_config_t *ssl_config, bctbx_x509_certificate_t *cert, bctbx_signing_key_t *key);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_ciphersuites(bctbx_ssl_config_t *ssl_config,const int *ciphersuites);
/***** DTLS-SRTP functions *****/
BCTBX_PUBLIC bctbx_dtls_srtp_profile_t bctbx_ssl_get_dtls_srtp_protection_profile(bctbx_ssl_context_t *ssl_ctx);
BCTBX_PUBLIC int32_t bctbx_ssl_config_set_dtls_srtp_protection_profiles(bctbx_ssl_config_t *ssl_config, const bctbx_dtls_srtp_profile_t *profiles, size_t profiles_number);
BCTBX_PUBLIC int32_t bctbx_ssl_get_dtls_srtp_key_material(bctbx_ssl_context_t *ssl_ctx, char *output, size_t *output_length);
BCTBX_PUBLIC uint8_t bctbx_dtls_srtp_supported(void);
BCTBX_PUBLIC void bctbx_ssl_set_mtu(bctbx_ssl_context_t *ssl_ctx, uint16_t mtu);
/*****************************************************************************/
/***** Key exchanges defined algorithms *****/
/*****************************************************************************/
/**
* @brief Return a 32 bits unsigned integer, each bit set to one matches an
* available key agreement algorithm as defined in bctoolbox/include/crypto.h
*
* @return An unsigned integer of 32 flags matching key agreement algos
*/
BCTBX_PUBLIC uint32_t bctbx_key_agreement_algo_list(void);
/*****************************************************************************/
/***** Diffie-Hellman-Merkle key exchange *****/
/*****************************************************************************/
/**
* @brief Context for the Diffie-Hellman-Merkle key exchange
* Use RFC3526 values for G and P
*/
typedef struct bctbx_DHMContext_struct {
uint8_t algo; /**< Algorithm used for the key exchange mapped to an int: BCTBX_DHM_2048, BCTBX_DHM_3072 */
uint16_t primeLength; /**< Prime number length in bytes(256 or 384)*/
uint8_t *secret; /**< the random secret (X), this field may not be used if the crypto module implementation already store this value in his context */
uint8_t secretLength; /**< in bytes */
uint8_t *key; /**< the key exchanged (G^Y)^X mod P */
uint8_t *self; /**< this side of the public exchange G^X mod P */
uint8_t *peer; /**< the other side of the public exchange G^Y mod P */
void *cryptoModuleData; /**< a context needed by the crypto implementation */
}bctbx_DHMContext_t;
/**
*
* @brief Create a context for the DHM key exchange
* This function will also instantiate the context needed by the actual implementation of the crypto module
*
* @param[in] DHMAlgo The algorithm type(BCTBX_DHM_2048 or BCTBX_DHM_3072)
* @param[in] secretLength The length in byte of the random secret(X).
*
* @return The initialised context for the DHM calculation(must then be freed calling the destroyDHMContext function), NULL on error
*
*/
BCTBX_PUBLIC bctbx_DHMContext_t *bctbx_CreateDHMContext(uint8_t DHMAlgo, uint8_t secretLength);
/**
*
* @brief Generate the private secret X and compute the public value G^X mod P
* G, P and X length have been set by previous call to DHM_CreateDHMContext
*
* @param[in/out] context DHM context, will store the public value in ->self after this call
* @param[in] rngFunction pointer to a random number generator used to create the secret X
* @param[in] rngContext pointer to the rng context if neeeded
*
*/
BCTBX_PUBLIC void bctbx_DHMCreatePublic(bctbx_DHMContext_t *context, int (*rngFunction)(void *, uint8_t *, size_t), void *rngContext);
/**
*
* @brief Compute the secret key G^X^Y mod p
* G^X mod P has been computed in previous call to DHMCreatePublic
* G^Y mod P must have been set in context->peer
*
* @param[in/out] context Read the public values from context, export the key to context->key
* @param[in] rngFunction Pointer to a random number generation function, used for blinding countermeasure, may be NULL
* @param[in] rngContext Pointer to the RNG function context
*
*/
BCTBX_PUBLIC void bctbx_DHMComputeSecret(bctbx_DHMContext_t *context, int (*rngFunction)(void *, uint8_t *, size_t), void *rngContext);
/**
*
* @brief Clean DHM context. Secret and key, if present, are erased from memory(set to 0)
*
* @param context The context to deallocate
*
*/
BCTBX_PUBLIC void bctbx_DestroyDHMContext(bctbx_DHMContext_t *context);
/*****************************************************************************/
/***** Elliptic Curve Diffie-Hellman-Merkle key exchange *****/
/*****************************************************************************/
/**
*
* @brief return TRUE if the Elliptic Curve Cryptography is available
*/
BCTBX_PUBLIC int bctbx_crypto_have_ecc(void);
/**
* @brief Context for the EC Diffie-Hellman-Merkle key exchange on curve 25519 and 448
* Use RFC7748 for base points values
*/
typedef struct bctbx_ECDHContext_struct {
uint8_t algo; /**< Algorithm used for the key exchange mapped to an int: BCTBX_ECDH_X25519, BCTBX_ECDH_X448 */
uint16_t pointCoordinateLength; /**< length in bytes of the point u-coordinate, can be 32 or 56 */
uint8_t *secret; /**< the random secret (scalar) used to compute public key and shared secret */
uint8_t secretLength; /**< in bytes, usually the same than pointCoordinateLength */
uint8_t *sharedSecret; /**< the key exchanged scalar multiplation of MULT(Self Secret, MULT(Peer Secret, BasePoint)), u-coordinate */
uint8_t *selfPublic; /**< this side of the public exchange: MULT(self secret, BasePoint), u-coordinate */
uint8_t *peerPublic; /**< the other side of the public exchange: MULT(peer secret, BasePoint), u-coordinate */
void *cryptoModuleData; /**< a context needed by the underlying crypto implementation - note if in use, most of the previous buffers could be store in it actually */
}bctbx_ECDHContext_t;
/**
*
* @brief Create a context for the ECDH key exchange
*
* @param[in] ECDHAlgo The algorithm type(BCTBX_ECDH_X25519 or BCTBX_ECDH_X448)
*
* @return The initialised context for the ECDH calculation(must then be freed calling the destroyECDHContext function), NULL on error
*
*/
BCTBX_PUBLIC bctbx_ECDHContext_t *bctbx_CreateECDHContext(const uint8_t ECDHAlgo);
/**
*
* @brief Generate the private secret scalar and compute the public key MULT(scalar, BasePoint)
*
* @param[in/out] context ECDH context, will store the public value in ->selfPublic after this call, and secret in ->secret
* @param[in] rngFunction pointer to a random number generator used to create the secret
* @param[in] rngContext pointer to the rng context if neeeded
*
*/
BCTBX_PUBLIC void bctbx_ECDHCreateKeyPair(bctbx_ECDHContext_t *context, int (*rngFunction)(void *, uint8_t *, size_t), void *rngContext);
/**
*
* @brief Set the given secret key in the ECDH context
*
* @param[in/out] context ECDH context, will store the given secret key if length is matching the pre-setted algo for this context
* @param[in] secret The buffer holding the secret, is duplicated in the ECDH context
* @param[in] secretLength Length of previous buffer, must match the algo type setted at context creation
*/
BCTBX_PUBLIC void bctbx_ECDHSetSecretKey(bctbx_ECDHContext_t *context, const uint8_t *secret, const size_t secretLength);
/**
*
* @brief Set the given self public key in the ECDH context
* Warning: no check if it matches the private key value
*
* @param[in/out] context ECDH context, will store the given self public key if length is matching the pre-setted algo for this context
* @param[in] selfPublic The buffer holding the self public key, is duplicated in the ECDH context
* @param[in] selfPublicLength Length of previous buffer, must match the algo type setted at context creation
*/
BCTBX_PUBLIC void bctbx_ECDHSetSelfPublicKey(bctbx_ECDHContext_t *context, const uint8_t *selfPublic, const size_t selfPublicLength);
/**
*
* @brief Set the given peer public key in the ECDH context
*
* @param[in/out] context ECDH context, will store the given peer public key if length is matching the pre-setted algo for this context
* @param[in] peerPublic The buffer holding the peer public key, is duplicated in the ECDH context
* @param[in] peerPublicLength Length of previous buffer, must match the algo type setted at context creation
*/
BCTBX_PUBLIC void bctbx_ECDHSetPeerPublicKey(bctbx_ECDHContext_t *context, const uint8_t *peerPublic, const size_t peerPublicLength);
/**
*
* @brief Derive the public key from the secret setted in context and using preselected algo, following RFC7748
*
* @param[in/out] context The context holding algo setting and secret, used to store public key
*/
BCTBX_PUBLIC void bctbx_ECDHDerivePublicKey(bctbx_ECDHContext_t *context);
/**
*
* @brief Compute the shared secret MULT(secret, peer Public)
* ->peerPublic, containing MULT(peerSecret, basePoint) must have been set before this call in context
*
* @param[in/out] context Read the public values from context, export the key to context->sharedSecret
* @param[in] rngFunction Pointer to a random number generation function, used for blinding countermeasure, may be NULL
* @param[in] rngContext Pointer to the RNG function context
*
*/
BCTBX_PUBLIC void bctbx_ECDHComputeSecret(bctbx_ECDHContext_t *context, int (*rngFunction)(void *, uint8_t *, size_t), void *rngContext);
/**
*
* @brief Clean ECDH context. Secret and key, if present, are erased from memory(set to 0)
*
* @param context The context to deallocate
*
*/
BCTBX_PUBLIC void bctbx_DestroyECDHContext(bctbx_ECDHContext_t *context);
/*****************************************************************************/
/***** EdDSA: signature and verify using Elliptic curves *****/
/*****************************************************************************/
/**
* @brief Context for the EdDSA using curves 25519 and 448
*/
typedef struct bctbx_EDDSAContext_struct {
uint8_t algo; /**< Algorithm used for the key exchange mapped to an int: BCTBX_EDDSA_25519, BCTBX_EDDSA_448 */
uint16_t pointCoordinateLength; /**< length in bytes of a serialised point coordinate, can be 32 or 57 */
uint8_t *secretKey; /**< the random secret (scalar) used to compute public key and message signature, is the same length than a serialised point coordinate */
uint8_t secretLength; /**< in bytes, usually the same than pointCoordinateLength */
uint8_t *publicKey; /**< MULT(HASH(secretKey), BasePoint), serialised coordinate */
void *cryptoModuleData; /**< a context needed by the underlying crypto implementation - note if in use, most of the previous buffers could be store in it actually */
}bctbx_EDDSAContext_t;
/**
*
* @brief Create a context for the EdDSA sign/verify
*
* @param[in] EDDSAAlgo The algorithm type(BCTBX_EDDSA_25519 or BCTBX_EDDSA_448)
*
* @return The initialised context for the EDDSA calculation(must then be freed calling the destroyEDDSAContext function), NULL on error
*
*/
BCTBX_PUBLIC bctbx_EDDSAContext_t *bctbx_CreateEDDSAContext(uint8_t EDDSAAlgo);
/**
*
* @brief Generate the private secret scalar and compute the public MULT(scalar, BasePoint)
*
* @param[in/out] context EDDSA context, will store the public value in ->publicKey after this call, and secret in ->secretKey
* @param[in] rngFunction pointer to a random number generator used to create the secret
* @param[in] rngContext pointer to the rng context if neeeded
*
*/
BCTBX_PUBLIC void bctbx_EDDSACreateKeyPair(bctbx_EDDSAContext_t *context, int (*rngFunction)(void *, uint8_t *, size_t), void *rngContext);
/**
*
* @brief Using the private secret scalar already set in context, compute the public MULT(scalar, BasePoint)
*
* @param[in/out] context EDDSA context, will store the public value in ->publicKey after this call, already have secret in ->secretKey
*
*/
BCTBX_PUBLIC void bctbx_EDDSADerivePublicKey(bctbx_EDDSAContext_t *context);
/**
*
* @brief Clean ECDH context. Secret and key, if present, are erased from memory(set to 0)
*
* @param context The context to deallocate
*
*/
BCTBX_PUBLIC void bctbx_DestroyEDDSAContext(bctbx_EDDSAContext_t *context);
/**
*
* @brief Sign the message given using private key and EdDSA algo set in context
*
* @param[in] context EDDSA context storing the algorithm to use(ed448 or ed25519) and the private key to use
* @param[in] message The message to be signed
* @param[in] messageLength Length of the message buffer
* @param [in] associatedData A "context" for this signature of up to 255 bytes.
* @param [in] associatedDataLength Length of the context.
* @param[out] signature The signature
* @param[in/out] signatureLength The size of the signature buffer as input, the size of the actual signature as output
*
*/
BCTBX_PUBLIC void bctbx_EDDSA_sign(bctbx_EDDSAContext_t *context, const uint8_t *message, const size_t messageLength, const uint8_t *AssociatedData, const uint8_t associatedDataLength, uint8_t *signature, size_t *signatureLength);
/**
*
* @brief Set a public key in a EDDSA context to be used to verify messages signature
*
* @param[in/out] context EDDSA context storing the algorithm to use(ed448 or ed25519)
* @param[in] publicKey The public to store in context
* @param[in] publicKeyLength The length of previous buffer
*/
BCTBX_PUBLIC void bctbx_EDDSA_setPublicKey(bctbx_EDDSAContext_t *context, const uint8_t *publicKey, const size_t publicKeyLength);
/**
*
* @brief Set a private key in a EDDSA context to be used to sign message
*
* @param[in/out] context EDDSA context storing the algorithm to use(ed448 or ed25519)
* @param[in] secretKey The secret to store in context
* @param[in] secretKeyLength The length of previous buffer
*/
BCTBX_PUBLIC void bctbx_EDDSA_setSecretKey(bctbx_EDDSAContext_t *context, const uint8_t *secretKey, const size_t secretKeyLength);
/**
*
* @brief Use the public key set in context to verify the given signature and message
*
* @param[in/out] context EDDSA context storing the algorithm to use(ed448 or ed25519) and public key
* @param[in] message Message to verify
* @param[in] messageLength Length of the message buffer
* @param [in] associatedData A "context" for this signature of up to 255 bytes.
* @param [in] associatedDataLength Length of the context.
* @param[in] signature The signature
* @param[in] signatureLength The size of the signature buffer
*
* @return BCTBX_VERIFY_SUCCESS or BCTBX_VERIFY_FAILED
*/
BCTBX_PUBLIC int bctbx_EDDSA_verify(bctbx_EDDSAContext_t *context, const uint8_t *message, size_t messageLength, const uint8_t *associatedData, const uint8_t associatedDataLength, const uint8_t *signature, size_t signatureLength);
/**
*
* @brief Convert a EDDSA private key to a ECDH private key
* pass the EDDSA private key through the hash function used in EdDSA
*
* @param[in] ed Context holding the current private key to convert
* @param[out] x Context to store the private key for x25519 key exchange
*/
BCTBX_PUBLIC void bctbx_EDDSA_ECDH_privateKeyConversion(const bctbx_EDDSAContext_t *ed, bctbx_ECDHContext_t *x);
#define BCTBX_ECDH_ISPEER 0
#define BCTBX_ECDH_ISSELF 1
/**
*
* @brief Convert a EDDSA public key to a ECDH public key
* point conversion : montgomeryX = (edwardsY + 1)*inverse(1 - edwardsY) mod p
*
* @param[in] ed Context holding the current public key to convert
* @param[out] x Context to store the public key for x25519 key exchange
* @param[in] isSelf Flag to decide where to store the public key in context: BCTBX_ECDH_ISPEER or BCTBX_ECDH_ISPEER
*/
BCTBX_PUBLIC void bctbx_EDDSA_ECDH_publicKeyConversion(const bctbx_EDDSAContext_t *ed, bctbx_ECDHContext_t *x, uint8_t isSelf);
/*****************************************************************************/
/***** Hashing *****/
/*****************************************************************************/
/*
* @brief SHA512 wrapper
* @param[in] input Input data buffer
* @param[in] inputLength Input data length in bytes
* @param[in] hashLength Length of output required in bytes, Output is truncated to the hashLength left bytes. 64 bytes maximum
* @param[out] output Output data buffer.
*
*/
BCTBX_PUBLIC void bctbx_sha512(const uint8_t *input,
size_t inputLength,
uint8_t hashLength,
uint8_t *output);
/*
* @brief SHA384 wrapper
* @param[in] input Input data buffer
* @param[in] inputLength Input data length in bytes
* @param[in] hashLength Length of output required in bytes, Output is truncated to the hashLength left bytes. 48 bytes maximum
* @param[out] output Output data buffer.
*
*/
BCTBX_PUBLIC void bctbx_sha384(const uint8_t *input,
size_t inputLength,
uint8_t hashLength,
uint8_t *output);
/**
* @brief SHA256 wrapper
* @param[in] input Input data buffer
* @param[in] inputLength Input data length in bytes
* @param[in] hmacLength Length of output required in bytes, SHA256 output is truncated to the hashLength left bytes. 32 bytes maximum
* @param[out] output Output data buffer.
*
*/
BCTBX_PUBLIC void bctbx_sha256(const uint8_t *input,
size_t inputLength,
uint8_t hashLength,
uint8_t *output);
/*
* @brief HMAC-SHA512 wrapper
* @param[in] key HMAC secret key
* @param[in] keyLength HMAC key length
* @param[in] input Input data buffer
* @param[in] inputLength Input data length
* @param[in] hmacLength Length of output required in bytes, HMAC output is truncated to the hmacLength left bytes. 64 bytes maximum
* @param[out] output Output data buffer.
*
*/
BCTBX_PUBLIC void bctbx_hmacSha512(const uint8_t *key,
size_t keyLength,
const uint8_t *input,
size_t inputLength,
uint8_t hmacLength,
uint8_t *output);
/**
* @brief HMAC-SHA384 wrapper
* @param[in] key HMAC secret key
* @param[in] keyLength HMAC key length in bytes
* @param[in] input Input data buffer
* @param[in] inputLength Input data length in bytes
* @param[in] hmacLength Length of output required in bytes, HMAC output is truncated to the hmacLength left bytes. 48 bytes maximum
* @param[out] output Output data buffer.
*
*/
BCTBX_PUBLIC void bctbx_hmacSha384(const uint8_t *key,
size_t keyLength,
const uint8_t *input,
size_t inputLength,
uint8_t hmacLength,
uint8_t *output);
/**
* @brief HMAC-SHA256 wrapper
* @param[in] key HMAC secret key
* @param[in] keyLength HMAC key length in bytes
* @param[in] input Input data buffer
* @param[in] inputLength Input data length in bytes
* @param[in] hmacLength Length of output required in bytes, HMAC output is truncated to the hmacLength left bytes. 32 bytes maximum
* @param[out] output Output data buffer.
*
*/
BCTBX_PUBLIC void bctbx_hmacSha256(const uint8_t *key,
size_t keyLength,
const uint8_t *input,
size_t inputLength,
uint8_t hmacLength,
uint8_t *output);
/**
* @brief HMAC-SHA1 wrapper
* @param[in] key HMAC secret key
* @param[in] keyLength HMAC key length
* @param[in] input Input data buffer
* @param[in] inputLength Input data length
* @param[in] hmacLength Length of output required in bytes, HMAC output is truncated to the hmacLength left bytes. 20 bytes maximum
* @param[out] output Output data buffer
*
*/
BCTBX_PUBLIC void bctbx_hmacSha1(const uint8_t *key,
size_t keyLength,
const uint8_t *input,
size_t inputLength,
uint8_t hmacLength,
uint8_t *output);
/**
* @brief MD5 wrapper
* output = md5(input)
* @param[in] input Input data buffer
* @param[in] inputLength Input data length in bytes
* @param[out] output Output data buffer.
*
*/
BCTBX_PUBLIC void bctbx_md5(const uint8_t *input,
size_t inputLength,
uint8_t output[16]);
/*****************************************************************************/
/***** Encryption/Decryption *****/
/*****************************************************************************/
typedef struct bctbx_aes_gcm_context_struct bctbx_aes_gcm_context_t;
/**
* @Brief AES-GCM encrypt and tag buffer
*
* @param[in] key Encryption key
* @param[in] keyLength Key buffer length, in bytes, must be 16,24 or 32
* @param[in] plainText buffer to be encrypted
* @param[in] plainTextLength Length in bytes of buffer to be encrypted
* @param[in] authenticatedData Buffer holding additional data to be used in tag computation
* @param[in] authenticatedDataLength Additional data length in bytes
* @param[in] initializationVector Buffer holding the initialisation vector
* @param[in] initializationVectorLength Initialisation vector length in bytes
* @param[out] tag Buffer holding the generated tag
* @param[in] tagLength Requested length for the generated tag
* @param[out] output Buffer holding the output, shall be at least the length of plainText buffer
*
* @return 0 on success, crypto library error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_aes_gcm_encrypt_and_tag(const uint8_t *key, size_t keyLength,
const uint8_t *plainText, size_t plainTextLength,
const uint8_t *authenticatedData, size_t authenticatedDataLength,
const uint8_t *initializationVector, size_t initializationVectorLength,
uint8_t *tag, size_t tagLength,
uint8_t *output);
/**
* @Brief AES-GCM decrypt, compute authentication tag and compare it to the one provided
*
* @param[in] key Encryption key
* @param[in] keyLength Key buffer length, in bytes, must be 16,24 or 32
* @param[in] cipherText Buffer to be decrypted
* @param[in] cipherTextLength Length in bytes of buffer to be decrypted
* @param[in] authenticatedData Buffer holding additional data to be used in auth tag computation
* @param[in] authenticatedDataLength Additional data length in bytes
* @param[in] initializationVector Buffer holding the initialisation vector
* @param[in] initializationVectorLength Initialisation vector length in bytes
* @param[in] tag Buffer holding the authentication tag
* @param[in] tagLength Length in bytes for the authentication tag
* @param[out] output Buffer holding the output, shall be at least the length of cipherText buffer
*
* @return 0 on succes, BCTBX_ERROR_AUTHENTICATION_FAILED if tag doesn't match or crypto library error code
*/
BCTBX_PUBLIC int32_t bctbx_aes_gcm_decrypt_and_auth(const uint8_t *key, size_t keyLength,
const uint8_t *cipherText, size_t cipherTextLength,
const uint8_t *authenticatedData, size_t authenticatedDataLength,
const uint8_t *initializationVector, size_t initializationVectorLength,
const uint8_t *tag, size_t tagLength,
uint8_t *output);
/**
* @Brief create and initialise an AES-GCM encryption context
*
* @param[in] key encryption key
* @param[in] keyLength key buffer length, in bytes, must be 16,24 or 32
* @param[in] authenticatedData Buffer holding additional data to be used in tag computation
* @param[in] authenticatedDataLength additional data length in bytes
* @param[in] initializationVector Buffer holding the initialisation vector
* @param[in] initializationVectorLength Initialisation vector length in bytes
* @param[in] mode Operation mode : BCTBX_GCM_ENCRYPT or BCTBX_GCM_DECRYPT
*
* @return a pointer to the created context, to be freed using bctbx_aes_gcm_finish()
*/
BCTBX_PUBLIC bctbx_aes_gcm_context_t *bctbx_aes_gcm_context_new(const uint8_t *key, size_t keyLength,
const uint8_t *authenticatedData, size_t authenticatedDataLength,
const uint8_t *initializationVector, size_t initializationVectorLength,
uint8_t mode);
/**
* @Brief AES-GCM encrypt or decrypt a chunk of data
*
* @param[in/out] context a context already initialized using bctbx_aes_gcm_context_new
* @param[in] input buffer holding the input data
* @param[in] inputLength length of the input data
* @param[out] output buffer to store the output data (same length as input one)
*
* @return 0 on success, crypto library error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_aes_gcm_process_chunk(bctbx_aes_gcm_context_t *context,
const uint8_t *input, size_t inputLength,
uint8_t *output);
/**
* @Brief Conclude a AES-GCM encryption stream, generate tag if requested, free resources
*
* @param[in/out] context a context already initialized using bctbx_aes_gcm_context_new
* @param[out] tag a buffer to hold the authentication tag. Can be NULL if tagLength is 0
* @param[in] tagLength length of requested authentication tag, max 16
*
* @return 0 on success, crypto library error code otherwise
*/
BCTBX_PUBLIC int32_t bctbx_aes_gcm_finish(bctbx_aes_gcm_context_t *context,
uint8_t *tag, size_t tagLength);
/**
* @brief Wrapper for AES-128 in CFB128 mode encryption
* Both key and IV must be 16 bytes long
*
* @param[in] key encryption key, 128 bits long
* @param[in] IV Initialisation vector, 128 bits long, is not modified by this function.
* @param[in] input Input data buffer
* @param[in] inputLength Input data length
* @param[out] output Output data buffer
*
*/
BCTBX_PUBLIC void bctbx_aes128CfbEncrypt(const uint8_t *key,
const uint8_t *IV,
const uint8_t *input,
size_t inputLength,
uint8_t *output);
/**
* @brief Wrapper for AES-128 in CFB128 mode decryption
* Both key and IV must be 16 bytes long
*
* @param[in] key decryption key, 128 bits long
* @param[in] IV Initialisation vector, 128 bits long, is not modified by this function.
* @param[in] input Input data buffer
* @param[in] inputLength Input data length
* @param[out] output Output data buffer
*
*/
BCTBX_PUBLIC void bctbx_aes128CfbDecrypt(const uint8_t *key,
const uint8_t *IV,
const uint8_t *input,
size_t inputLength,
uint8_t *output);
/**
* @brief Wrapper for AES-256 in CFB128 mode encryption
* The key must be 32 bytes long and the IV must be 16 bytes long
*
* @param[in] key encryption key, 256 bits long
* @param[in] IV Initialisation vector, 128 bits long, is not modified by this function.
* @param[in] input Input data buffer
* @param[in] inputLength Input data length
* @param[out] output Output data buffer
*
*/
BCTBX_PUBLIC void bctbx_aes256CfbEncrypt(const uint8_t *key,
const uint8_t *IV,
const uint8_t *input,
size_t inputLength,
uint8_t *output);
/**
* @brief Wrapper for AES-256 in CFB128 mode decryption
* The key must be 32 bytes long and the IV must be 16 bytes long
*
* @param[in] key decryption key, 256 bits long
* @param[in] IV Initialisation vector, 128 bits long, is not modified by this function.
* @param[in] input Input data buffer
* @param[in] inputLength Input data length
* @param[out] output Output data buffer
*
*/
BCTBX_PUBLIC void bctbx_aes256CfbDecrypt(const uint8_t *key,
const uint8_t *IV,
const uint8_t *input,
size_t inputLength,
uint8_t *output);
/**
* @brief encrypt the file in input buffer for linphone encrypted file transfer
*
* This function must be called with NULL in the plain text to conclude the encryption.
* At this last call, if a cipher buffer is provided with non 0 length, it will get an authentication tag of the requested size (max 16)
*
* @param[in/out] cryptoContext a context already initialized using bctbx_aes_gcm_context_new (created if NULL)
* @param[in] key encryption key
* @param[in] length buffer size
* @param[in] plain buffer holding the input data
* @param[out] cipher buffer to store the output data (cipher or authentication tag)
*/
BCTBX_PUBLIC int bctbx_aes_gcm_encryptFile(void **cryptoContext, unsigned char *key, size_t length, char *plain, char *cipher);
/**
* @brief decrypt the file in input buffer for linphone encrypted file transfer
*
* This function must be called with NULL in the cipher text to conclude the encryption.
* At this last call, if a plain buffer is provided with non 0 length, it will get the authentication tag of length bytes (max 16)
*
* @param[in/out] cryptoContext a context already initialized using bctbx_aes_gcm_context_new
* @param[in] key encryption key
* @param[in] length input buffer size
* @param[out] plain buffer holding the output data (plain text or tag)
* @param[in] cipher buffer to store the input data. WARNING: size must be a multiple of 16 bytes
*/
BCTBX_PUBLIC int bctbx_aes_gcm_decryptFile(void **cryptoContext, unsigned char *key, size_t length, char *plain, char *cipher);
/*****************************************************************************/
/***** Cleaning *****/
/*****************************************************************************/
/**
* @brief force a buffer values to zero in a way that shall prevent the compiler from optimizing it out
*
* @param[in/out] buffer the buffer to be cleared
* @param[in] size buffer size
*/
BCTBX_PUBLIC void bctbx_clean(void *buffer, size_t size);
#ifdef __cplusplus
}
#endif
#endif /* BCTBX_CRYPTO_H */
bctoolbox-4.4.13/include/bctoolbox/defs.h 0000664 0000000 0000000 00000002130 13757173071 0020315 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_DEFS_H_
#define BCTBX_DEFS_H_
/* Macro telling GCC that a 'break' statement has been deliberately omitted
* in switch block */
#ifndef BCTBX_NO_BREAK
#if defined(__GNUC__) && __GNUC__ >= 7
#define BCTBX_NO_BREAK __attribute__((fallthrough))
#else
#define BCTBX_NO_BREAK
#endif // __GNUC__
#endif // BCTBX_NO_BREAK
#endif /* BCTBX_DEFS_H_ */
bctoolbox-4.4.13/include/bctoolbox/exception.hh 0000664 0000000 0000000 00000004125 13757173071 0021550 0 ustar 00root root 0000000 0000000 /*
bctoolbox
Copyright (C) 2016 Belledonne Communications SARL.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Affero 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 Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see .
*/
#ifndef exception_h
#define exception_h
#include
#include
#include "bctoolbox/port.h"
#ifdef _WIN32
#pragma warning (push)
#pragma warning (disable : 4275 4251)
#endif
/**
* @brief General pupose exception saving backtrace.
*
* sample of use:
* try {
* throw BCTBX_EXCEPTION << "Hello, this is my exception";
* } catch (BctbxException e&) {
* BCTOOLBOX_SLOGD("mylogdomain") << "Exception cauth"<< e;
* }
*
*
*/
class BCTBX_PUBLIC BctbxException : public std::exception {
public:
BctbxException(const std::string &message = "");
BctbxException(const BctbxException &other);
virtual ~BctbxException() = default;
/**
* print stack strace to stderr
* */
void printStackTrace() const;
void printStackTrace(std::ostream &os) const;
const char *what() const noexcept override;
const std::string& str() const;
/* same as osstringstream, but as osstream does not have cp contructor, BctbxException can't inherit from
* osstream*/
template BctbxException &operator<<(const T2 &val) {
mOs << val;
return *this;
}
private:
void *mArray[20];
size_t mSize;
std::ostringstream mOs;
mutable std::string mMessage;
};
BCTBX_PUBLIC std::ostream &operator<<(std::ostream &__os, const BctbxException &e);
#define BCTBX_EXCEPTION BctbxException() << " " << __FILE__ << ":" << __LINE__ << " "
#ifdef _WIN32
#pragma warning (pop)
#endif
#endif /* exception_h */
bctoolbox-4.4.13/include/bctoolbox/ios_utils.hh 0000664 0000000 0000000 00000003247 13757173071 0021570 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2010-2019 Belledonne Communications SARL.
*
* This file is part of Liblinphone.
*
* 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 .
*/
#pragma once
#include
#include
namespace bctoolbox {
class IOSUtilsInterface {
public:
virtual unsigned long beginBackgroundTask(const char *name, std::function cb) = 0;
virtual void endBackgroundTask(unsigned long id) = 0;
virtual bool isApplicationStateActive() = 0;
virtual ~IOSUtilsInterface() = default;
};
class IOSUtils {
public:
unsigned long beginBackgroundTask(const char *name, std::function cb);
void endBackgroundTask(unsigned long id);
bool isApplicationStateActive();
static IOSUtils& getUtils();
IOSUtils(const IOSUtils&) = delete;
IOSUtils& operator=(const IOSUtils&) = delete;
~IOSUtils();
private:
void *mHandle;
IOSUtilsInterface *mUtils;
static std::unique_ptr sInstance;
IOSUtils();
bool isApp();
void openDynamicLib();
void *loadSymbol(const char *symbol);
};
} //namespace bctoolbox
bctoolbox-4.4.13/include/bctoolbox/list.h 0000664 0000000 0000000 00000010727 13757173071 0020362 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_LIST_H_
#define BCTBX_LIST_H_
#include "bctoolbox/port.h"
#ifdef __cplusplus
extern "C"{
#endif
typedef struct _bctbx_list {
struct _bctbx_list *next;
struct _bctbx_list *prev;
void *data;
} bctbx_list_t;
typedef int (*bctbx_compare_func)(const void *, const void*);
typedef void (*bctbx_list_iterate_func)(void *);
typedef void (*bctbx_list_iterate2_func)(void *, void *);
typedef void (*bctbx_list_free_func)(void *);
typedef void* (*bctbx_list_copy_func)(void *);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_new(void *data);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_append(bctbx_list_t * elem, void * data);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_append_link(bctbx_list_t * elem, bctbx_list_t *new_elem);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_prepend(bctbx_list_t * elem, void * data);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_prepend_link(bctbx_list_t* elem, bctbx_list_t *new_elem);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_last_elem(const bctbx_list_t *l);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_first_elem(const bctbx_list_t *l);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_free(bctbx_list_t * elem);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_concat(bctbx_list_t * first, bctbx_list_t * second);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_remove(bctbx_list_t * first, void *data);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_remove_custom(bctbx_list_t *first, bctbx_compare_func compare_func, const void *user_data);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_pop_front(bctbx_list_t *list, void **front_data);
BCTBX_PUBLIC size_t bctbx_list_size(const bctbx_list_t * first);
BCTBX_PUBLIC void bctbx_list_for_each(const bctbx_list_t * list, bctbx_list_iterate_func func);
BCTBX_PUBLIC void bctbx_list_for_each2(const bctbx_list_t * list, bctbx_list_iterate2_func func, void *user_data);
/**
* Removes the element pointed by elem from the list. The element itself is not freed, allowing
* to be chained in another list for example.
* Use bctbx_list_erase_link() if you simply want to delete an element of a list.
**/
BCTBX_PUBLIC bctbx_list_t * bctbx_list_unlink(bctbx_list_t * list, bctbx_list_t * elem);
/**
* Delete the element pointed by 'elem' from the list.
**/
BCTBX_PUBLIC bctbx_list_t * bctbx_list_erase_link(bctbx_list_t * list, bctbx_list_t * elem);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_find(bctbx_list_t *list, const void *data);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_free(bctbx_list_t *list);
/*frees list elements and associated data, using the supplied function pointer*/
BCTBX_PUBLIC bctbx_list_t * bctbx_list_free_with_data(bctbx_list_t *list, bctbx_list_free_func freefunc);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_find_custom(const bctbx_list_t * list, bctbx_compare_func cmp, const void *user_data);
BCTBX_PUBLIC void * bctbx_list_nth_data(const bctbx_list_t * list, int index);
BCTBX_PUBLIC int bctbx_list_position(const bctbx_list_t * list, bctbx_list_t * elem);
BCTBX_PUBLIC int bctbx_list_index(const bctbx_list_t * list, void *data);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_insert_sorted(bctbx_list_t * list, void *data, bctbx_compare_func cmp);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_insert(bctbx_list_t * list, bctbx_list_t * before, void *data);
BCTBX_PUBLIC bctbx_list_t * bctbx_list_copy(const bctbx_list_t * list);
/*copy list elements and associated data, using the supplied function pointer*/
BCTBX_PUBLIC bctbx_list_t* bctbx_list_copy_with_data(const bctbx_list_t* list, bctbx_list_copy_func copyfunc);
/*Same as bctbx_list_copy_with_data but in reverse order*/
BCTBX_PUBLIC bctbx_list_t* bctbx_list_copy_reverse_with_data(const bctbx_list_t* list, bctbx_list_copy_func copyfunc);
BCTBX_PUBLIC bctbx_list_t* bctbx_list_next(const bctbx_list_t *elem);
BCTBX_PUBLIC void* bctbx_list_get_data(const bctbx_list_t *elem);
#ifdef __cplusplus
}
#endif
#endif /* BCTLBX_LIST_H_ */
bctoolbox-4.4.13/include/bctoolbox/logging.h 0000664 0000000 0000000 00000026776 13757173071 0021050 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
/**
* \file logging.h
* \brief Logging API.
*
**/
#ifndef BCTBX_LOGGING_H
#define BCTBX_LOGGING_H
#include
#include "bctoolbox/list.h"
/**
* The BCTBX_LOG_DOMAIN macro should be defined with a preprocessor directive (ex: -DBCTBX_LOG_DOMAIN="my-component") in every
* software entity (application, library, sub-parts of software etc) using the bctoolbox log facility, so that all invocations of the
* bctbx_message(), bctbx_warning(), bctbx_error(), bctbx_fatal() outputs their log within the domain title of the software part there are compiled in.
* It SHALL not be defined in any public header, otherwise it will conflict with upper layer using the logging facility for their own domain.
* As a special exception, bctoolbox defines the log domain to be "bctbx" if no preprocessor directive defines it.
* As a result, bctboolbox owns logs will be output into the "bctbx" domain.
**/
#ifndef BCTBX_LOG_DOMAIN
#define BCTBX_LOG_DOMAIN "bctbx"
#endif
#ifdef __cplusplus
extern "C"
{
#endif
typedef enum {
BCTBX_LOG_DEBUG=1,
BCTBX_LOG_TRACE=1<<1,
BCTBX_LOG_MESSAGE=1<<2,
BCTBX_LOG_WARNING=1<<3,
BCTBX_LOG_ERROR=1<<4,
BCTBX_LOG_FATAL=1<<5,
BCTBX_LOG_LOGLEV_END=1<<6
} BctbxLogLevel;
typedef struct _bctbx_log_handler_t bctbx_log_handler_t;
typedef void (*BctbxLogFunc)(const char *domain, BctbxLogLevel lev, const char *fmt, va_list args);
typedef void (*BctbxLogHandlerFunc)(void *info,const char *domain, BctbxLogLevel lev, const char *fmt, va_list args);
typedef void (*BctbxLogHandlerDestroyFunc)(bctbx_log_handler_t *handler);
/*
initialise logging functions, add default log handler for stdout output.
@param[in] bool_t create : No longer used, always created with a default logger to stdout.
*/
BCTBX_PUBLIC void bctbx_init_logger(bool_t create);
/*
free logging memory
*/
BCTBX_PUBLIC void bctbx_uninit_logger(void);
/*
Default functions to free log handlers
@param[in] bctbx_log_handler_t* handler : the handler to free
*/
BCTBX_PUBLIC void bctbx_logv_out_destroy(bctbx_log_handler_t *handler);
BCTBX_PUBLIC void bctbx_logv_file_destroy(bctbx_log_handler_t *handler);
/*
Function to create a log handler
@param[in] BctbxLogHandlerFunc func : the function to call to handle a new line of log
@param[in] BctbxLogHandlerDestroyFunc destroy : the function to call to free this handler particuler its user_info field
@param[in] void* user_info : complementary information to handle the logs if needed
@return a new bctbx_log_handler_t
*/
BCTBX_PUBLIC bctbx_log_handler_t* bctbx_create_log_handler(BctbxLogHandlerFunc func, BctbxLogHandlerDestroyFunc destroy, void* user_data);
/*
Function to create a file log handler
@param[in] uint64_t max_size : the maximum size of the log file before rotating to a new one (if 0 then no rotation)
@param[in] const char* path : the path where to put the log files
@param[in] const char* name : the name of the log files
@param[in] FILE* f : the file where to write the logs
@return a new bctbx_log_handler_t
*/
BCTBX_PUBLIC bctbx_log_handler_t* bctbx_create_file_log_handler(uint64_t max_size, const char* path, const char* name);
/**
* @brief Request reopening of the log file.
* @param[in] file_log_handler The log handler whose file will be reopened.
* @note This function is thread-safe and reopening is done asynchronously.
*/
BCTBX_PUBLIC void bctbx_file_log_handler_reopen(bctbx_log_handler_t *file_log_handler);
/* set domain the handler is limited to. NULL for ALL*/
BCTBX_PUBLIC void bctbx_log_handler_set_domain(bctbx_log_handler_t * log_handler,const char *domain);
BCTBX_PUBLIC void bctbx_log_handler_set_user_data(bctbx_log_handler_t*, void* user_data);
BCTBX_PUBLIC void *bctbx_log_handler_get_user_data(const bctbx_log_handler_t* log_handler);
BCTBX_PUBLIC void bctbx_add_log_handler(bctbx_log_handler_t* handler);
BCTBX_PUBLIC void bctbx_remove_log_handler(bctbx_log_handler_t* handler);
/*
* Set a callback function to render logs for the default handler.
*/
BCTBX_PUBLIC void bctbx_set_log_handler(BctbxLogFunc func);
/*
* Same as bctbx_set_log_handler but only for a domain. NULL for all.
* Be careful that if domain is specified, the default log handler will no longer output logs for other domains.
*/
BCTBX_PUBLIC void bctbx_set_log_handler_for_domain(BctbxLogFunc func, const char* domain);
/*Convenient function that creates a static log handler logging into supplied FILE argument.
Despite it is not recommended to use it in libraries, it can be useful for simple test programs.*/
BCTBX_PUBLIC void bctbx_set_log_file(FILE* f);
BCTBX_PUBLIC bctbx_list_t* bctbx_get_log_handlers(void);
BCTBX_PUBLIC void bctbx_logv_out(const char *domain, BctbxLogLevel level, const char *fmt, va_list args);
BCTBX_PUBLIC void bctbx_logv_file(void* user_info, const char *domain, BctbxLogLevel level, const char *fmt, va_list args);
/*
* Returns 1 if the log level 'level' is enabled for the calling thread, otherwise 0.
* This gives the condition to decide to output a log.
*/
BCTBX_PUBLIC int bctbx_log_level_enabled(const char *domain, BctbxLogLevel level);
BCTBX_PUBLIC void bctbx_logv(const char *domain, BctbxLogLevel level, const char *fmt, va_list args);
/**
* Flushes the log output queue.
* WARNING: Must be called from the thread that has been defined with bctbx_set_log_thread_id().
*/
BCTBX_PUBLIC void bctbx_logv_flush(void);
/**
* Activate all log level greater or equal than specified level argument.
**/
BCTBX_PUBLIC void bctbx_set_log_level(const char *domain, BctbxLogLevel level);
BCTBX_PUBLIC void bctbx_set_log_level_mask(const char *domain, int levelmask);
BCTBX_PUBLIC unsigned int bctbx_get_log_level_mask(const char *domain);
/**
* Set a specific log level for the calling thread for domain.
* When domain is NULL, the log level applies to all domains.
*/
BCTBX_PUBLIC void bctbx_set_thread_log_level(const char *domain, BctbxLogLevel level);
/**
* Clears the specific log level set for the calling thread by bctbx_set_thread_log_level().
* After calling this function, the global (not per thread) log level will apply to
* logs printed by this thread.
*/
BCTBX_PUBLIC void bctbx_clear_thread_log_level(const char *domain);
/**
* Tell oRTP the id of the thread used to output the logs.
* This is meant to output all the logs from the same thread to prevent deadlock problems at the application level.
* @param[in] thread_id The id of the thread that will output the logs (can be obtained using bctbx_thread_self()).
*/
BCTBX_PUBLIC void bctbx_set_log_thread_id(unsigned long thread_id);
#ifdef __GNUC__
#define CHECK_FORMAT_ARGS(m,n) __attribute__((format(printf,m,n)))
#else
#define CHECK_FORMAT_ARGS(m,n)
#endif
#ifdef __clang__
/*in case of compile with -g static inline can produce this type of warning*/
#pragma GCC diagnostic ignored "-Wunused-function"
#endif
#ifdef BCTBX_DEBUG_MODE
static BCTBX_INLINE void CHECK_FORMAT_ARGS(1,2) bctbx_debug(const char *fmt,...)
{
va_list args;
va_start (args, fmt);
bctbx_logv(BCTBX_LOG_DOMAIN, BCTBX_LOG_DEBUG, fmt, args);
va_end (args);
}
#else
#define bctbx_debug(...)
#endif
#ifdef BCTBX_NOMESSAGE_MODE
#define bctbx_log(...)
#define bctbx_message(...)
#define bctbx_warning(...)
#else
static BCTBX_INLINE void bctbx_log(const char* domain, BctbxLogLevel lev, const char *fmt,...) {
va_list args;
va_start (args, fmt);
bctbx_logv(domain, lev, fmt, args);
va_end (args);
}
static BCTBX_INLINE void CHECK_FORMAT_ARGS(1,2) bctbx_message(const char *fmt,...)
{
va_list args;
va_start (args, fmt);
bctbx_logv(BCTBX_LOG_DOMAIN, BCTBX_LOG_MESSAGE, fmt, args);
va_end (args);
}
static BCTBX_INLINE void CHECK_FORMAT_ARGS(1,2) bctbx_warning(const char *fmt,...)
{
va_list args;
va_start (args, fmt);
bctbx_logv(BCTBX_LOG_DOMAIN, BCTBX_LOG_WARNING, fmt, args);
va_end (args);
}
#endif
static BCTBX_INLINE void CHECK_FORMAT_ARGS(1,2) bctbx_error(const char *fmt,...)
{
va_list args;
va_start (args, fmt);
bctbx_logv(BCTBX_LOG_DOMAIN, BCTBX_LOG_ERROR, fmt, args);
va_end (args);
}
static BCTBX_INLINE void CHECK_FORMAT_ARGS(1,2) bctbx_fatal(const char *fmt,...)
{
va_list args;
va_start (args, fmt);
bctbx_logv(BCTBX_LOG_DOMAIN, BCTBX_LOG_FATAL, fmt, args);
va_end (args);
}
#ifdef __QNX__
void bctbx_qnx_log_handler(const char *domain, BctbxLogLevel lev, const char *fmt, va_list args);
#endif
#ifdef __cplusplus
}
#include
#include
#include
#if !defined(_WIN32) && !defined(__QNX__)
#include
#endif
namespace bctoolbox {
namespace log {
// Here we define our application severity levels.
enum level { normal, trace, debug, info, warning, error, fatal };
// The formatting logic for the severity level
template
inline std::basic_ostream &operator<<(std::basic_ostream &strm,
const bctoolbox::log::level &lvl) {
static const char *const str[] = {"normal", "trace", "debug", "info", "warning", "error", "fatal"};
if (static_cast(lvl) < (sizeof(str) / sizeof(*str)))
strm << str[lvl];
else
strm << static_cast(lvl);
return strm;
}
template
inline std::basic_istream &operator>>(std::basic_istream &strm,
bctoolbox::log::level &lvl) {
static const char *const str[] = {"normal", "trace", "debug", "info", "warning", "error", "fatal"};
std::string s;
strm >> s;
for (unsigned int n = 0; n < (sizeof(str) / sizeof(*str)); ++n) {
if (s == str[n]) {
lvl = static_cast(n);
return strm;
}
}
// Parse error
strm.setstate(std::ios_base::failbit);
return strm;
}
}
}
#include
class pumpstream : public std::ostringstream {
public:
/*contructor used to disable logging*/
pumpstream():mDomain(""),mLevel(BCTBX_LOG_DEBUG),mTraceEnabled(false){}
pumpstream(const char *domain, BctbxLogLevel level) : mDomain(domain ? domain : ""), mLevel(level),mTraceEnabled(true) {}
~pumpstream() {
const char *domain = mDomain.empty() ? NULL : mDomain.c_str();
if (mTraceEnabled && bctbx_log_level_enabled(domain, mLevel))
bctbx_log(domain, mLevel, "%s", str().c_str());
}
private:
const std::string mDomain;
const BctbxLogLevel mLevel;
const bool mTraceEnabled;
};
#if (__GNUC__ == 4 && __GNUC_MINOR__ < 5 && __cplusplus > 199711L)
template inline pumpstream &operator<<(pumpstream &&__os, const _Tp &__x) {
(static_cast(__os)) << __x;
return __os;
}
#endif
#define BCTBX_SLOG(domain, thelevel) pumpstream(domain, thelevel)
#ifndef BCTBX_DEBUG_MODE
#define BCTBX_SLOGD BCTBX_SLOG(BCTBX_LOG_DOMAIN, BCTBX_LOG_DEBUG)
#else
#define BCTBX_SLOGD pumpstream()
#endif
#define BCTBX_SLOGI BCTBX_SLOG(BCTBX_LOG_DOMAIN, BCTBX_LOG_MESSAGE)
#define BCTBX_SLOGW BCTBX_SLOG(BCTBX_LOG_DOMAIN, BCTBX_LOG_WARNING)
#define BCTBX_SLOGE BCTBX_SLOG(BCTBX_LOG_DOMAIN, BCTBX_LOG_ERROR)
#endif
#endif
bctoolbox-4.4.13/include/bctoolbox/map.h 0000664 0000000 0000000 00000014036 13757173071 0020161 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_MMAP_H_
#define BCTBX_MMAP_H_
#include "bctoolbox/list.h"
#include "bctoolbox/port.h"
#ifdef __cplusplus
extern "C"{
#endif
typedef struct _bctbx_map_t bctbx_map_t;
typedef struct _bctbx_pair_t bctbx_pair_t;
typedef struct _bctbx_iterator_t bctbx_iterator_t;
typedef struct _bctbx_mmap_ullong_t bctbx_mmap_ullong_t;
typedef struct _bctbx_mmap_cchar_t bctbx_mmap_cchar_t;
typedef void (*bctbx_map_free_func)(void *);
/*map*/
BCTBX_PUBLIC bctbx_map_t *bctbx_mmap_ullong_new(void);
BCTBX_PUBLIC bctbx_map_t *bctbx_mmap_cchar_new(void);
BCTBX_PUBLIC void bctbx_mmap_ullong_delete(bctbx_map_t *mmap);
BCTBX_PUBLIC void bctbx_mmap_cchar_delete(bctbx_map_t *mmap);
BCTBX_PUBLIC void bctbx_mmap_ullong_delete_with_data(bctbx_map_t *mmap, bctbx_map_free_func freefunc);
BCTBX_PUBLIC void bctbx_mmap_cchar_delete_with_data(bctbx_map_t *mmap, bctbx_map_free_func freefunc);
#define bctbx_map_insert bctbx_map_ullong_insert
BCTBX_PUBLIC void bctbx_map_ullong_insert(bctbx_map_t *map,const bctbx_pair_t *pair);
BCTBX_PUBLIC void bctbx_map_cchar_insert(bctbx_map_t *map,const bctbx_pair_t *pair);
/*same as insert, but also deleting pair*/
#define bctbx_map_insert_and_delete bctbx_map_ullong_insert_and_delete
BCTBX_PUBLIC void bctbx_map_ullong_insert_and_delete(bctbx_map_t *map,bctbx_pair_t *pair);
BCTBX_PUBLIC void bctbx_map_cchar_insert_and_delete(bctbx_map_t *map,bctbx_pair_t *pair);
/*same as insert and deleting pair with a newly allocated it returned */
#define bctbx_map_insert_and_delete_with_returned_it bctbx_map_ullong_insert_and_delete_with_returned_it
BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_ullong_insert_and_delete_with_returned_it(bctbx_map_t *map,bctbx_pair_t *pair);
BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_cchar_insert_and_delete_with_returned_it(bctbx_map_t *map,bctbx_pair_t *pair);
/*at return, it point to the next element*/
#define bctbx_map_erase bctbx_map_ullong_erase
BCTBX_PUBLIC bctbx_iterator_t *bctbx_map_ullong_erase(bctbx_map_t *map,bctbx_iterator_t *it);
BCTBX_PUBLIC bctbx_iterator_t *bctbx_map_cchar_erase(bctbx_map_t *map,bctbx_iterator_t *it);
/*return a new allocated iterator*/
#define bctbx_map_begin bctbx_map_ullong_begin
BCTBX_PUBLIC bctbx_iterator_t *bctbx_map_ullong_begin(const bctbx_map_t *map);
BCTBX_PUBLIC bctbx_iterator_t *bctbx_map_cchar_begin(const bctbx_map_t *map);
/*return a new allocated iterator*/
#define bctbx_map_end bctbx_map_ullong_end
BCTBX_PUBLIC bctbx_iterator_t *bctbx_map_ullong_end(const bctbx_map_t *map);
BCTBX_PUBLIC bctbx_iterator_t *bctbx_map_cchar_end(const bctbx_map_t *map);
/*return a new allocated iterator or null*/
#define bctbx_map_find_custom bctbx_map_ullong_find_custom
BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_ullong_find_custom(const bctbx_map_t *map, bctbx_compare_func compare_func, const void *user_data);
BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_cchar_find_custom(const bctbx_map_t *map, bctbx_compare_func compare_func, const void *user_data);
/*return the iterator associated to the key in the map or Null*/
BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_ullong_find_key(const bctbx_map_t *map, unsigned long long key);
BCTBX_PUBLIC bctbx_iterator_t * bctbx_map_cchar_find_key(const bctbx_map_t *map, const char * key);
/* return the size of the map*/
#define bctbx_map_size bctbx_map_ullong_size
BCTBX_PUBLIC size_t bctbx_map_ullong_size(const bctbx_map_t *map);
BCTBX_PUBLIC size_t bctbx_map_cchar_size(const bctbx_map_t *map);
/*iterator*/
#define bctbx_iterator_get_pair bctbx_iterator_ullong_get_pair
BCTBX_PUBLIC bctbx_pair_t *bctbx_iterator_ullong_get_pair(const bctbx_iterator_t *it);
BCTBX_PUBLIC bctbx_pair_t *bctbx_iterator_cchar_get_pair(const bctbx_iterator_t *it);
/*return same pointer but pointing to next*/
#define bctbx_iterator_get_next bctbx_iterator_ullong_get_next
BCTBX_PUBLIC bctbx_iterator_t *bctbx_iterator_ullong_get_next(bctbx_iterator_t *it);
BCTBX_PUBLIC bctbx_iterator_t *bctbx_iterator_cchar_get_next(bctbx_iterator_t *it);
#define bctbx_iterator_equals bctbx_iterator_ullong_equals
BCTBX_PUBLIC bool_t bctbx_iterator_ullong_equals(const bctbx_iterator_t *a,const bctbx_iterator_t *b);
BCTBX_PUBLIC bool_t bctbx_iterator_cchar_equals(const bctbx_iterator_t *a,const bctbx_iterator_t *b);
#define bctbx_iterator_delete bctbx_iterator_ullong_delete
BCTBX_PUBLIC void bctbx_iterator_ullong_delete(bctbx_iterator_t *it);
BCTBX_PUBLIC void bctbx_iterator_cchar_delete(bctbx_iterator_t *it);
/*pair*/
typedef struct _bctbx_pair_ullong_t bctbx_pair_ullong_t; /*inherit from bctbx_pair_t*/
BCTBX_PUBLIC bctbx_pair_ullong_t * bctbx_pair_ullong_new(unsigned long long key,void *value);
typedef struct _bctbx_pair_cchar_t bctbx_pair_cchar_t; /*inherit from bctbx_pair_t*/
BCTBX_PUBLIC bctbx_pair_cchar_t * bctbx_pair_cchar_new(const char * key,void *value);
#define bctbx_pair_get_second bctbx_pair_ullong_get_second
BCTBX_PUBLIC void* bctbx_pair_ullong_get_second(const bctbx_pair_t * pair);
BCTBX_PUBLIC void* bctbx_pair_cchar_get_second(const bctbx_pair_t * pair);
BCTBX_PUBLIC unsigned long long bctbx_pair_ullong_get_first(const bctbx_pair_ullong_t * pair);
BCTBX_PUBLIC const char * bctbx_pair_cchar_get_first(const bctbx_pair_cchar_t * pair);
#define bctbx_pair_delete bctbx_pair_ullong_delete
BCTBX_PUBLIC void bctbx_pair_ullong_delete(bctbx_pair_t * pair);
BCTBX_PUBLIC void bctbx_pair_cchar_delete(bctbx_pair_t * pair);
#ifdef __cplusplus
}
#endif
#endif /* BCTBX_LIST_H_ */
bctoolbox-4.4.13/include/bctoolbox/parser.h 0000664 0000000 0000000 00000006646 13757173071 0020710 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_PARSER_H_
#define BCTBX_PARSER_H_
#include "bctoolbox/port.h"
#ifdef __cplusplus
extern "C"
{
#endif
/**
* A 256 entries table where each entries defines if character corresponding to its index is allowed or not (value = 0)
* for instance noescape_rules[':'] = 1 means that ':' should not be escaped
*/
typedef unsigned char bctbx_noescape_rules_t[256+1]; /*last entry (BCTBX_NOESCAPE_RULES_USER_INDEX) is reserved for user purpose. Might be usefull to set if array was initialed of not */
#define BCTBX_NOESCAPE_RULES_USER_INDEX (sizeof(bctbx_noescape_rules_t) -1)
/**
* Allocate a new string with unauthorized characters escaped (I.E replaced by % HEX HEX) if any.
* sample:
* bctbx_noescape_rules_t my_rules = {0}; nothing allowed
* bctbx_noescape_rules_add_alfanums(my_rules);
* char * my_escaped_string = bctbx_escape("François",my_rules);
* expeted result my_escaped_string == Fran%c3%a7ois
* @param buff NULL terminated input buffer.
* @param noescape_rules bctbx_noescape_rules_t to apply for this input buff
* @return a newly allocated null terminated string
*/
BCTBX_PUBLIC char* bctbx_escape(const char* buff, const bctbx_noescape_rules_t noescape_rules);
/**
* Add a list of allowed charaters to a noescape rule.
* @param noescape_rules rule to be modified.
* @param allowed string representing allowed char. Sample: ";-/"
*/
BCTBX_PUBLIC void bctbx_noescape_rules_add_list(bctbx_noescape_rules_t noescape_rules, const char *allowed);
/**
* Add a range of allowed charaters to noescape rule. bctbx_noescape_rules_add_range(noescape_rules, '0','9') is the same as bctbx_noescape_rules_add_list(noescape_rules,"0123456789")
* @param noescape_rules rule to be modified.
* @param first allowed char.
* @param last allowed char.
*/
BCTBX_PUBLIC void bctbx_noescape_rules_add_range(bctbx_noescape_rules_t noescape_rules, char first, char last);
/**
* Add ['0'..'9'], ['a'..'z'] ['A'..'z'] to no escape rule.
*/
BCTBX_PUBLIC void bctbx_noescape_rules_add_alfanums(bctbx_noescape_rules_t noescape_rules);
/**
* Allocate a new string with escaped character (I.E % HEX HEX) replaced by unicode char.
* @param buff NULL terminated input buffer.
* @return a newly allocated null terminated string with unescated values.
*/
BCTBX_PUBLIC char* bctbx_unescaped_string(const char* buff);
/**
*Convert a single input "a" into unscaped output if need.
* a = "%c3%a7" into "ç" with return value = 3
* a = "A" into "A" with return value = 1
* @param a input value
* @param out outbut buffer for conversion
* @return number of byte wrote into out
*/
BCTBX_PUBLIC size_t bctbx_get_char (const char *a, char *out);
#ifdef __cplusplus
}
#endif
#endif /*BCTBX_PARSER_H_*/
bctoolbox-4.4.13/include/bctoolbox/port.h 0000664 0000000 0000000 00000062175 13757173071 0020377 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
/* this file is responsible of the portability of the stack */
#ifndef BCTBX_PORT_H
#define BCTBX_PORT_H
#if !defined(_WIN32) && !defined(_WIN32_WCE)
/********************************/
/* definitions for UNIX flavour */
/********************************/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef __linux
#include
#endif
#include
#include
#include
#if defined(_XOPEN_SOURCE_EXTENDED) || !defined(__hpux)
#include
#endif
#include
#include
typedef int bctbx_socket_t;
typedef pthread_t bctbx_thread_t;
typedef pthread_mutex_t bctbx_mutex_t;
typedef pthread_cond_t bctbx_cond_t;
#ifdef __INTEL_COMPILER
#pragma warning(disable : 111) // statement is unreachable
#pragma warning(disable : 181) // argument is incompatible with corresponding format string conversion
#pragma warning(disable : 188) // enumerated type mixed with another type
#pragma warning(disable : 593) // variable "xxx" was set but never used
#pragma warning(disable : 810) // conversion from "int" to "unsigned short" may lose significant bits
#pragma warning(disable : 869) // parameter "xxx" was never referenced
#pragma warning(disable : 981) // operands are evaluated in unspecified order
#pragma warning(disable : 1418) // external function definition with no prior declaration
#pragma warning(disable : 1419) // external declaration in primary source file
#pragma warning(disable : 1469) // "cc" clobber ignored
#endif
#ifndef BCTBX_DEPRECATED
#define BCTBX_DEPRECATED __attribute__ ((deprecated))
#endif
#define BCTBX_PUBLIC
#define BCTBX_INLINE inline
#define BCTBX_EWOULDBLOCK EWOULDBLOCK
#define BCTBX_EINPROGRESS EINPROGRESS
#define BCTBX_ENETUNREACH ENETUNREACH
#define BCTBX_EHOSTUNREACH EHOSTUNREACH
#define BCTBX_ENOTCONN ENOTCONN
#define BCTBX_EPROTOTYPE EPROTOTYPE /* Protocol wrong type for socket */
#ifdef __cplusplus
extern "C"
{
#endif
int __bctbx_thread_join(bctbx_thread_t thread, void **ptr);
int __bctbx_thread_create(bctbx_thread_t *thread, pthread_attr_t *attr, void * (*routine)(void*), void *arg);
unsigned long __bctbx_thread_self(void);
#ifdef __cplusplus
}
#endif
#define bctbx_thread_create __bctbx_thread_create
#define bctbx_thread_join __bctbx_thread_join
#define bctbx_thread_self __bctbx_thread_self
#define bctbx_thread_exit pthread_exit
#define bctbx_mutex_init pthread_mutex_init
#define bctbx_mutex_lock pthread_mutex_lock
#define bctbx_mutex_unlock pthread_mutex_unlock
#define bctbx_mutex_destroy pthread_mutex_destroy
#define bctbx_cond_init pthread_cond_init
#define bctbx_cond_signal pthread_cond_signal
#define bctbx_cond_broadcast pthread_cond_broadcast
#define bctbx_cond_wait pthread_cond_wait
#define bctbx_cond_destroy pthread_cond_destroy
#define bctbx_inet_aton inet_aton
#define SOCKET_OPTION_VALUE void *
#define SOCKET_BUFFER void *
#define getSocketError() strerror(errno)
#define getSocketErrorCode() (errno)
#define getSocketErrorWithCode(code) strerror(code)
#define bctbx_gettimeofday(tv,tz) gettimeofday(tv,tz)
#define bctbx_log10f(x) log10f(x)
#else
/*********************************/
/* definitions for WIN32 flavour */
/*********************************/
#include
#define _CRT_RAND_S
#include
#include
#include
#include
#ifdef _MSC_VER
#include
#endif
#if defined(__MINGW32__) || !defined(WINAPI_FAMILY_PARTITION) || !defined(WINAPI_PARTITION_DESKTOP)
#define BCTBX_WINDOWS_DESKTOP 1
#elif defined(WINAPI_FAMILY_PARTITION)
#if defined(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
#define BCTBX_WINDOWS_DESKTOP 1
#elif defined(WINAPI_PARTITION_PHONE_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
#define BCTBX_WINDOWS_PHONE 1
#elif defined(WINAPI_PARTITION_APP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#define BCTBX_WINDOWS_UNIVERSAL 1
#endif
#endif
#ifndef BCTBX_DEPRECATED
#define BCTBX_DEPRECATED __declspec(deprecated)
#endif
#if defined(_WIN32) || defined(_WIN32_WCE)
#ifdef BCTBX_STATIC
#define BCTBX_PUBLIC
#define BCTBX_VAR_PUBLIC extern
#else
#ifdef BCTBX_EXPORTS
#define BCTBX_PUBLIC __declspec(dllexport)
#define BCTBX_VAR_PUBLIC extern __declspec(dllexport)
#else
#define BCTBX_PUBLIC __declspec(dllimport)
#define BCTBX_VAR_PUBLIC __declspec(dllimport)
#endif
#endif
#pragma push_macro("_WINSOCKAPI_")
#ifndef _WINSOCKAPI_
#define _WINSOCKAPI_
#endif
#define strtok_r strtok_s
typedef unsigned __int64 uint64_t;
typedef __int64 int64_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef int int32_t;
typedef unsigned char uint8_t;
typedef __int16 int16_t;
typedef long ssize_t;
#else
#include /*provided by mingw32*/
#include
#define BCTBX_PUBLIC
#define BCTBX_VAR_PUBLIC extern
BCTBX_PUBLIC char* strtok_r(char *str, const char *delim, char **nextp);
#endif
#define vsnprintf _vsnprintf
typedef SOCKET bctbx_socket_t;
#ifdef BCTBX_WINDOWS_DESKTOP
typedef HANDLE bctbx_cond_t;
typedef HANDLE bctbx_mutex_t;
#else
typedef CONDITION_VARIABLE bctbx_cond_t;
typedef SRWLOCK bctbx_mutex_t;
#endif
typedef HANDLE bctbx_thread_t;
#define bctbx_thread_create __bctbx_WIN_thread_create
#define bctbx_thread_join __bctbx_WIN_thread_join
#define bctbx_thread_self __bctbx_WIN_thread_self
#define bctbx_thread_exit(arg)
#define bctbx_mutex_init __bctbx_WIN_mutex_init
#define bctbx_mutex_lock __bctbx_WIN_mutex_lock
#define bctbx_mutex_unlock __bctbx_WIN_mutex_unlock
#define bctbx_mutex_destroy __bctbx_WIN_mutex_destroy
#define bctbx_cond_init __bctbx_WIN_cond_init
#define bctbx_cond_signal __bctbx_WIN_cond_signal
#define bctbx_cond_broadcast __bctbx_WIN_cond_broadcast
#define bctbx_cond_wait __bctbx_WIN_cond_wait
#define bctbx_cond_destroy __bctbx_WIN_cond_destroy
#define bctbx_inet_aton __bctbx_WIN_inet_aton
#ifdef __cplusplus
extern "C"
{
#endif
BCTBX_PUBLIC int __bctbx_WIN_mutex_init(bctbx_mutex_t *m, void *attr_unused);
BCTBX_PUBLIC int __bctbx_WIN_mutex_lock(bctbx_mutex_t *mutex);
BCTBX_PUBLIC int __bctbx_WIN_mutex_unlock(bctbx_mutex_t *mutex);
BCTBX_PUBLIC int __bctbx_WIN_mutex_destroy(bctbx_mutex_t *mutex);
BCTBX_PUBLIC int __bctbx_WIN_thread_create(bctbx_thread_t *t, void *attr_unused, void *(*func)(void*), void *arg);
BCTBX_PUBLIC int __bctbx_WIN_thread_join(bctbx_thread_t thread, void **unused);
BCTBX_PUBLIC unsigned long __bctbx_WIN_thread_self(void);
BCTBX_PUBLIC int __bctbx_WIN_cond_init(bctbx_cond_t *cond, void *attr_unused);
BCTBX_PUBLIC int __bctbx_WIN_cond_wait(bctbx_cond_t * cond, bctbx_mutex_t * mutex);
BCTBX_PUBLIC int __bctbx_WIN_cond_signal(bctbx_cond_t * cond);
BCTBX_PUBLIC int __bctbx_WIN_cond_broadcast(bctbx_cond_t * cond);
BCTBX_PUBLIC int __bctbx_WIN_cond_destroy(bctbx_cond_t * cond);
BCTBX_PUBLIC int __bctbx_WIN_inet_aton (const char * cp, struct in_addr * addr);
#ifdef __cplusplus
}
#endif
#define SOCKET_OPTION_VALUE char *
#define BCTBX_INLINE __inline
#define BCTBX_EWOULDBLOCK WSAEWOULDBLOCK
#define BCTBX_EINPROGRESS WSAEINPROGRESS
#define BCTBX_ENETUNREACH WSAENETUNREACH
#define BCTBX_EHOSTUNREACH WSAEHOSTUNREACH
#define BCTBX_ENOTCONN WSAENOTCONN
#define BCTBX_EPROTOTYPE WSAEPROTOTYPE /* Protocol wrong type for socket */
#if defined(_WIN32_WCE)
#define bctbx_log10f(x) (float)log10 ((double)x)
#ifdef assert
#undef assert
#endif /*assert*/
#define assert(exp) ((void)0)
#ifdef errno
#undef errno
#endif /*errno*/
#define errno GetLastError()
#ifdef strerror
#undef strerror
#endif /*strerror*/
const char * bctbx_strerror(DWORD value);
#define strerror bctbx_strerror
#else /*_WIN32_WCE*/
#define bctbx_log10f(x) log10f(x)
#endif
#ifdef __cplusplus
extern "C" {
#endif
BCTBX_PUBLIC const char *__bctbx_getWinSocketError(int error);
#ifdef __cplusplus
}
#endif
#ifndef getSocketErrorCode
#define getSocketErrorCode() WSAGetLastError()
#endif
#ifndef getSocketError
#define getSocketError() __bctbx_getWinSocketError(WSAGetLastError())
#endif
#ifndef getSocketErrorWithCode
#define getSocketErrorWithCode(code) __bctbx_getWinSocketError(code)
#endif
#ifndef snprintf
#define snprintf _snprintf
#endif
#ifndef strcasecmp
#define strcasecmp _stricmp
#endif
#ifndef strncasecmp
#define strncasecmp _strnicmp
#endif
#ifndef strdup
#define strdup _strdup
#endif
#ifndef unlink
#define unlink _unlink
#endif
#ifndef F_OK
#define F_OK 00 /* Visual Studio does not define F_OK */
#endif
#ifdef __cplusplus
extern "C"{
#endif
BCTBX_PUBLIC int bctbx_gettimeofday (struct timeval *tv, void* tz);
#ifdef _WORKAROUND_MINGW32_BUGS
char * WSAAPI gai_strerror(int errnum);
#endif
#ifdef __cplusplus
}
#endif
#endif
#ifndef _BOOL_T_
#define _BOOL_T_
typedef unsigned char bool_t;
#endif /* _BOOL_T_ */
#undef TRUE
#undef FALSE
#define TRUE 1
#define FALSE 0
#ifndef MIN
#define MIN(a,b) (((a)>(b)) ? (b) : (a))
#endif
#ifndef MAX
#define MAX(a,b) (((a)>(b)) ? (a) : (b))
#endif
typedef struct bctoolboxTimeSpec{
int64_t tv_sec;
int64_t tv_nsec;
}bctoolboxTimeSpec;
#ifdef __cplusplus
extern "C"{
#endif
BCTBX_PUBLIC void* bctbx_malloc(size_t sz);
BCTBX_PUBLIC void bctbx_free(void *ptr);
BCTBX_PUBLIC void* bctbx_realloc(void *ptr, size_t sz);
BCTBX_PUBLIC void* bctbx_malloc0(size_t sz);
BCTBX_PUBLIC char * bctbx_strdup(const char *tmp);
/*override the allocator with this method, to be called BEFORE bctbx_init()*/
typedef struct _BctoolboxMemoryFunctions{
void *(*malloc_fun)(size_t sz);
void *(*realloc_fun)(void *ptr, size_t sz);
void (*free_fun)(void *ptr);
}BctoolboxMemoryFunctions;
void bctbx_set_memory_functions(BctoolboxMemoryFunctions *functions);
#define bctbx_new(type,count) (type*)bctbx_malloc(sizeof(type)*(count))
#define bctbx_new0(type,count) (type*)bctbx_malloc0(sizeof(type)*(count))
BCTBX_PUBLIC int bctbx_socket_set_non_blocking(bctbx_socket_t sock);
#ifdef __GNUC__
# define BCTBX_PRINTF_LIKE(format_pos, args_pos) __attribute__ ((format (printf, format_pos, args_pos)))
#else
# define BCTBX_PRINTF_LIKE(format_pos, args_pos)
#endif
BCTBX_PUBLIC char *bctbx_strndup(const char *str,int n);
BCTBX_PUBLIC char *bctbx_strdup_printf(const char *fmt,...) BCTBX_PRINTF_LIKE(1, 2);
BCTBX_PUBLIC char *bctbx_strdup_vprintf(const char *fmt, va_list ap);
BCTBX_PUBLIC char *bctbx_strcat_printf(char *dst, const char *fmt,...) BCTBX_PRINTF_LIKE(2, 3);
BCTBX_PUBLIC char *bctbx_strcat_vprintf(char *dst, const char *fmt, va_list ap);
BCTBX_PUBLIC char *bctbx_concat(const char *str, ...);
BCTBX_PUBLIC char *bctbx_replace(char *str, char c, char n);
/**
* @brief Return the directory part of a file path.
*
* Find the last delimiting character ('/' or '\') and return a
* copy of the substring before. If no delimiter has been found,
* then "." string is returned.
*
* @param[in] path A string containing a file path. The behaviour
* is undefined if the string contains a path to a directoy. MUST be non-NULL.
* @return An allocated string containing the directory name.
*
* @warning This funciton isn't equivalent to libgen.h dirname().
*/
BCTBX_PUBLIC char *bctbx_dirname(const char *path);
/**
* @brief Return the name of a file from its path.
*
* Find the last delimiting character ('/' or '\') and return a
* copy of the substring after. If no delimiter has been found,
* then a copy of 'path' is returned.
*
* @param[in] path A string containing a file path. The behaviour
* is undefined if the string contains a path to a directoy. MUST be non-NULL.
* @return An allocated string containing the file name.
*
* @warning This funciton isn't equivalent to libgen.h basename().
*/
BCTBX_PUBLIC char *bctbx_basename(const char *path);
/**
* Tests if a file with given pathname exists. Return 0 if yes, -1 otherwise.
**/
BCTBX_PUBLIC int bctbx_file_exist(const char *pathname);
/**
* Tests if a directory with given pathname exists. Return 0 if yes, -1 otherwise.
**/
BCTBX_PUBLIC bool_t bctbx_directory_exists(const char *pathname);
/**
* @brief return a timeSpec structure(sec and nsec) containing current time(WARNING: there is no guarantees it is UTC ).
* The time returned may refers to UTC or last boot.
* Use this function only to compute a time span between two calls
* @param[in/out] ret The current time (seconds and nano seconds).
*/
BCTBX_PUBLIC void bctbx_get_cur_time(bctoolboxTimeSpec *ret);
/**
* @brief return a timeSpec structure(sec and nsec) containing current UTC time.
*
* @param[in/out] ret The current UTC time, (seconds and nano seconds)
*/
BCTBX_PUBLIC void bctbx_get_utc_cur_time(bctoolboxTimeSpec *ret);
BCTBX_PUBLIC uint64_t bctbx_get_cur_time_ms(void);
BCTBX_PUBLIC void bctbx_sleep_ms(int ms);
BCTBX_PUBLIC void bctbx_sleep_until(const bctoolboxTimeSpec *ts);
/**
* @brief Compares two TimeSpec s1 and s2.
*
* @param[in] s1 First time spec
* @param[in] s2 Second time spec
*
* @return a negative value if s1 is earlier than s2, 0 if they are equal, a positive value if s1 is later than s2
*/
BCTBX_PUBLIC int bctbx_timespec_compare(const bctoolboxTimeSpec *s1, const bctoolboxTimeSpec *s2);
/**
* @brief Add given amount of seconds to a timeSpec structure
*
* @param[in/out] ts The timeSpec structure used as input, modified in output by increnting it according to second argument
* @param[in] lap In seconds, number of seconds to modify the given timeSpec, can be negative(which may set the original timeSpec to 0)
*/
BCTBX_PUBLIC void bctbx_timespec_add(bctoolboxTimeSpec *ts, const int64_t lap);
/**
* @brief Parse a string into a number of seconds
* Accepted suffixes are Y,M,W,d,h,m,s number is expected to be a base 10 integer, no suffix means seconds
* notes:
* - M suffix(month) is consired a 30 days period without any consideration of the current date, Y is always 365 days.
* - You can combine suffixes in any order: 3Y6M is valid, 15d1M6h is valid too.
* - Any unknown suffix is silently ignored and the value preceding it is discarded
* - NULL or empty string('\0') in timeString are valid and return 0.
*
* @param[in] timeString a string formated like {[0-9]+[Y,M,W,d,h,m,s]?}*'\0' (must be null terminated)
* @return described time period in seconds
*/
BCTBX_PUBLIC uint32_t bctbx_time_string_to_sec(const char *timeString);
BCTBX_PUBLIC unsigned int bctbx_random(void);
BCTBX_PUBLIC ssize_t bctbx_send(bctbx_socket_t socket, const void *buffer, size_t length, int flags);
BCTBX_PUBLIC ssize_t bctbx_sendto(bctbx_socket_t socket, const void *message, size_t length, int flags, const struct sockaddr *dest_addr, socklen_t dest_len);
BCTBX_PUBLIC ssize_t bctbx_recv(bctbx_socket_t socket, void *buffer, size_t length, int flags);
BCTBX_PUBLIC ssize_t bctbx_recvfrom(bctbx_socket_t socket, void *buffer, size_t length, int flags, struct sockaddr *address, socklen_t *address_len);
BCTBX_PUBLIC ssize_t bctbx_read(int fd, void *buf, size_t nbytes);
BCTBX_PUBLIC ssize_t bctbx_write(int fd, const void *buf, size_t nbytes);
/* Portable and bug-less getaddrinfo */
BCTBX_PUBLIC int bctbx_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
BCTBX_PUBLIC void bctbx_freeaddrinfo(struct addrinfo *res);
BCTBX_PUBLIC int bctbx_getnameinfo(const struct sockaddr *address, socklen_t address_len, char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags);
BCTBX_PUBLIC int bctbx_addrinfo_to_ip_address(const struct addrinfo *ai, char *ip, size_t ip_size, int *port);
BCTBX_PUBLIC int bctbx_addrinfo_to_printable_ip_address(const struct addrinfo *ai, char *printable_ip, size_t printable_ip_size);
BCTBX_PUBLIC int bctbx_sockaddr_to_ip_address(const struct sockaddr *sa, socklen_t salen, char *ip, size_t ip_size, int *port);
BCTBX_PUBLIC int bctbx_sockaddr_to_printable_ip_address(struct sockaddr *sa, socklen_t salen, char *printable_ip, size_t printable_ip_size);
/** Sort a list of addrinfo with the following rules:
-IPV6 including NAT64.
-V4 MAPPED IPV6.
-V4.
**/
BCTBX_PUBLIC struct addrinfo *bctbx_addrinfo_sort(struct addrinfo *ai);
/**
* Convert a numeric ip address and port into an addrinfo, whose family will be as specified in the first argument.
* If AF_INET6 is requested, the returned addrinfo will always be an IPv6 address, possibly V4MAPPED if the
* ip address was a v4 address.
* Passing AF_UNSPEC to this function leads to unspecified results.
**/
BCTBX_PUBLIC struct addrinfo * bctbx_ip_address_to_addrinfo(int family, int socktype, const char *ipaddress, int port);
/**
* Convert a name or ip address and port into an addrinfo, whose family will be as specified in the first argument.
* If AF_INET6 is requested, the returned addrinfo will always be an IPv6 address, possibly a V4MAPPED if the
* ip address was a v4 address.
* Passing AF_UNSPEC to this function leads to unspecified results.
**/
BCTBX_PUBLIC struct addrinfo * bctbx_name_to_addrinfo(int family, int socktype, const char *name, int port);
/**
* This function will transform a V4 to V6 mapped address to a pure V4 and write it into result, or will just copy it otherwise.
* The memory for v6 and result may be the same, in which case processing is done in place or no copy is done.
* The pointer to result must have sufficient storage, typically a struct sockaddr_storage.
**/
BCTBX_PUBLIC void bctbx_sockaddr_remove_v4_mapping(const struct sockaddr *v6, struct sockaddr *result, socklen_t *result_len);
/**
* This function will transform a V6 NAT64 mapped address to a pure V4 and write it into result, or will just copy it otherwise.
* The memory for v6 and result may be the same, in which case processing is done in place or no copy is done.
* The pointer to result must have sufficient storage, typically a struct sockaddr_storage.
**/
BCTBX_PUBLIC void bctbx_sockaddr_remove_nat64_mapping(const struct sockaddr *v6, struct sockaddr *result, socklen_t *result_len);
/**
* This function will transform a V4 to V6 mapped address to a pure V4 and write it into result, or will just copy it otherwise.
* The memory for v6 and result may be the same, in which case processing is done in place or no copy is done.
* The pointer to result must have sufficient storage, typically a struct sockaddr_storage.
**/
BCTBX_PUBLIC void bctbx_sockaddr_ipv6_to_ipv4(const struct sockaddr *v6, struct sockaddr *result, socklen_t *result_len);
/**
* This function will transform any V4 address to a V4 mapped address and write it into result.
* The pointer to result must have sufficient storage, typically a struct sockaddr_storage.
**/
BCTBX_PUBLIC void bctbx_sockaddr_ipv4_to_ipv6(const struct sockaddr *v4, struct sockaddr *result, socklen_t *result_len);
/**
* Return TRUE if both families, ports and addresses are equals
*/
BCTBX_PUBLIC bool_t bctbx_sockaddr_equals(const struct sockaddr * sa, const struct sockaddr * sb) ;
/**
* Get the local IP address that is used to send data to a specific destination.
* @param[in] type The address family of the socket to use.
* @param[in] dest The destination address.
* @param[in] port The destination port.
* @param[out] result The local IP address that is used to send data to the destination.
* @param[in] result_len The size of the result buffer.
* @return 0 on success, a negative value on error.
**/
BCTBX_PUBLIC int bctbx_get_local_ip_for(int type, const char *dest, int port, char *result, size_t result_len);
/* portable named pipes and shared memory*/
#if !defined(_WIN32_WCE)
#ifdef _WIN32
typedef HANDLE bctbx_pipe_t;
#define BCTBX_PIPE_INVALID INVALID_HANDLE_VALUE
#else
typedef int bctbx_pipe_t;
#define BCTBX_PIPE_INVALID (-1)
#endif
BCTBX_PUBLIC bctbx_pipe_t bctbx_server_pipe_create(const char *name);
/*
* warning: on win32 bctbx_server_pipe_accept_client() might return INVALID_HANDLE_VALUE without
* any specific error, this happens when bctbx_server_pipe_close() is called on another pipe.
* This pipe api is not thread-safe.
*/
BCTBX_PUBLIC bctbx_pipe_t bctbx_server_pipe_accept_client(bctbx_pipe_t server);
BCTBX_PUBLIC int bctbx_server_pipe_close(bctbx_pipe_t spipe);
BCTBX_PUBLIC int bctbx_server_pipe_close_client(bctbx_pipe_t client);
BCTBX_PUBLIC bctbx_pipe_t bctbx_client_pipe_connect(const char *name);
BCTBX_PUBLIC int bctbx_client_pipe_close(bctbx_pipe_t sock);
BCTBX_PUBLIC int bctbx_pipe_read(bctbx_pipe_t p, uint8_t *buf, int len);
BCTBX_PUBLIC int bctbx_pipe_write(bctbx_pipe_t p, const uint8_t *buf, int len);
BCTBX_PUBLIC void *bctbx_shm_open(unsigned int keyid, int size, int create);
BCTBX_PUBLIC void bctbx_shm_close(void *memory);
BCTBX_PUBLIC bool_t bctbx_is_multicast_addr(const struct sockaddr *addr);
#endif
/**
* @brief convert an hexa char [0-9a-fA-F] into the corresponding unsigned integer value
* Any invalid char will be converted to zero without any warning
*
* @param[in] input_char a char which shall be in range [0-9a-fA-F]
*
* @return the unsigned integer value in range [0-15]
*/
BCTBX_PUBLIC uint8_t bctbx_char_to_byte(uint8_t input_char);
/**
* @brief convert a byte which value is in range [0-15] into an hexa char [0-9a-fA-F]
*
* @param[in] input_byte an integer which shall be in range [0-15]
* @return the hexa char [0-9a-f] corresponding to the input
*/
BCTBX_PUBLIC uint8_t bctbx_byte_to_char(uint8_t input_byte);
/**
* @brief Convert an hexadecimal string into the corresponding byte buffer
*
* @param[out] output_bytes The output bytes buffer, must have a length of half the input string buffer
* @param[in] input_string The input string buffer, must be hexadecimal(it is not checked by function, any non hexa char is converted to 0)
* @param[in] input_string_length The lenght in chars of the string buffer, output is half this length
*/
BCTBX_PUBLIC void bctbx_str_to_uint8(uint8_t *output_bytes, const uint8_t *input_string, size_t input_string_length);
/**
* @brief Convert a byte buffer into the corresponding hexadecimal string
*
* @param[out] output_string The output string buffer, must have a length of twice the input bytes buffer
* @param[in] input_bytes The input bytes buffer
* @param[in] input_bytes_length The lenght in bytes buffer, output is twice this length
*/
BCTBX_PUBLIC void bctbx_int8_to_str(uint8_t *output_string, const uint8_t *input_bytes, size_t input_bytes_length);
/**
* @brief Convert an unsigned 32 bits integer into the corresponding hexadecimal string(including null termination character)
*
* @param[out] output_string The output string buffer, must have a length of at least 9 bytes(8 nibbles and the '\0')
* @param[in] input_uint32 The input unsigned int
*/
BCTBX_PUBLIC void bctbx_uint32_to_str(uint8_t output_string[9], uint32_t input_uint32);
/**
* @brief Convert an hexadecimal string of 8 char length into the corresponding 32 bits unsigned integer
*
* @param[in] input_string The input string buffer, must be hexadecimal and at least 8 char long
*
* Note : there is no check on the length or validity as an hexa string on the input, incorrect byte is silently mapped to 0
*/
BCTBX_PUBLIC uint32_t bctbx_str_to_uint32(const uint8_t input_string[9]);
/**
* @brief Convert an unsigned 64 bits integer into the corresponding hexadecimal string(including null termination character)
*
* @param[out] output_string The output string buffer, must have a length of at least 17 bytes(16 nibbles and the '\0')
* @param[in] input_uint64 The input unsigned int
*/
BCTBX_PUBLIC void bctbx_uint64_to_str(uint8_t output_string[17], uint64_t input_uint64);
/**
* @brief Convert an hexadecimal string of 8 char length into the corresponding 64 bits unsigned integer
*
* @param[in] input_string The input string buffer, must be hexadecimal and at leat 16 char long
*
* Note : there is no check on the length or validity as an hexa string on the input, incorrect byte is silently mapped to 0
*/
BCTBX_PUBLIC uint64_t bctbx_str_to_uint64(const uint8_t input_string[17]);
#ifdef __cplusplus
}
#endif
#ifndef IN6_IS_ADDR_MULTICAST
#define IN6_IS_ADDR_MULTICAST(i) (((uint8_t *) (i))[0] == 0xff)
#endif
#if defined(_WIN32) || defined(__QNX__)
/* Mingw32 does not define AI_V4MAPPED, however it is supported starting from Windows Vista. QNX also does not define AI_V4MAPPED. */
# ifndef AI_V4MAPPED
# define AI_V4MAPPED 0x00000800
# endif
# ifndef AI_ALL
# define AI_ALL 0x00000100
# endif
# ifndef IPV6_V6ONLY
# define IPV6_V6ONLY 27
# endif
#endif
#endif
#if defined(_WIN32) || defined(__QNX__)
#define FORMAT_SIZE_T "%Iu"
#elif __APPLE__
#define FORMAT_SIZE_T "%lu"
#else
#define FORMAT_SIZE_T "%zu"
#endif
#if defined(__ANDROID__)
int mblen(const char* s, size_t n);
int wctomb(char *s, wchar_t wc);
#endif
bctoolbox-4.4.13/include/bctoolbox/regex.h 0000664 0000000 0000000 00000001722 13757173071 0020514 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_REGEX_H
#define BCTBX_REGEX_H
#ifdef __cplusplus
extern "C" {
#endif
BCTBX_PUBLIC bool_t bctbx_is_matching_regex(const char *entry, const char* regex);
#ifdef __cplusplus
}
#endif
#endif /* BCTBX_REGEX_H */
bctoolbox-4.4.13/include/bctoolbox/tester.h 0000664 0000000 0000000 00000023644 13757173071 0020717 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTOOLBOX_TESTER_H
#define BCTOOLBOX_TESTER_H
#include
#include
#include
#include
#include
typedef void (*test_function_t)(void);
/** Function used in all suites - it is invoked before all and each tests and also after each and all tests
* @return 0 means success, otherwise it's an error
**/
typedef int (*pre_post_function_t)(void);
// typedef int (*test_suite_function_t)(const char *name);
typedef struct {
const char *name;
test_function_t func;
const char *tags[2];
} test_t;
#define TEST_NO_TAG(name, func) \
{ name, func, { NULL, NULL } }
#define TEST_ONE_TAG(name, func, tag) \
{ name, func, { tag, NULL } }
#define TEST_TWO_TAGS(name, func, tag1, tag2) \
{ name, func, { tag1, tag2 } }
typedef struct {
const char *name; /*suite name*/
pre_post_function_t before_all; /*function invoked before running the suite. If not returning 0, suite is not launched. */
pre_post_function_t after_all; /*function invoked at the end of the suite, even if some tests failed. */
test_function_t before_each; /*function invoked before each test within this suite. */
test_function_t after_each; /*function invoked after each test within this suite, even if it failed. */
int nb_tests; /* number of tests */
test_t *tests; /* tests within this suite */
} test_suite_t;
#ifdef __cplusplus
extern "C" {
#endif
#define CHECK_ARG(argument, index, argc) \
if(index >= argc) { \
fprintf(stderr, "Missing argument for \"%s\"\n", argument); \
return -1; \
} \
BCTBX_PUBLIC void bc_tester_init(void (*ftester_printf)(int level, const char *fmt, va_list args)
, int verbosity_info, int verbosity_error, const char* expected_res);
BCTBX_PUBLIC void bc_tester_helper(const char *name, const char* additionnal_helper);
BCTBX_PUBLIC int bc_tester_parse_args(int argc, char** argv, int argid);
BCTBX_PUBLIC int bc_tester_start(const char* prog_name);
BCTBX_PUBLIC int bc_tester_register_suites(void);
BCTBX_PUBLIC int bc_tester_register_suite_by_name(const char *suite_name);
BCTBX_PUBLIC void bc_tester_add_suite(test_suite_t *suite);
BCTBX_PUBLIC void bc_tester_uninit(void);
BCTBX_PUBLIC void bc_tester_printf(int level, const char *fmt, ...);
BCTBX_PUBLIC const char * bc_tester_get_resource_dir_prefix(void);
BCTBX_PUBLIC void bc_tester_set_resource_dir_prefix(const char *name);
BCTBX_PUBLIC const char * bc_tester_get_writable_dir_prefix(void);
BCTBX_PUBLIC void bc_tester_set_writable_dir_prefix(const char *name);
BCTBX_PUBLIC void bc_tester_set_silent_func(int (*func)(const char*));
BCTBX_PUBLIC void bc_tester_set_verbose_func(int (*func)(const char*));
BCTBX_PUBLIC void bc_tester_set_logfile_func(int (*func)(const char*));
BCTBX_PUBLIC int bc_tester_nb_suites(void);
BCTBX_PUBLIC int bc_tester_nb_tests(const char* name);
BCTBX_PUBLIC void bc_tester_list_suites(void);
BCTBX_PUBLIC void bc_tester_list_tests(const char *suite_name);
BCTBX_PUBLIC const char * bc_tester_suite_name(int suite_index);
BCTBX_PUBLIC const char * bc_tester_test_name(const char *suite_name, int test_index);
BCTBX_PUBLIC int bc_tester_run_suite(test_suite_t *suite, const char *tag_name);
BCTBX_PUBLIC int bc_tester_run_tests(const char *suite_name, const char *test_name, const char *tag_name);
BCTBX_PUBLIC int bc_tester_suite_index(const char *suite_name);
BCTBX_PUBLIC const char * bc_tester_current_suite_name(void);
BCTBX_PUBLIC const char * bc_tester_current_test_name(void);
BCTBX_PUBLIC const char ** bc_tester_current_test_tags(void);
BCTBX_PUBLIC char* bc_sprintfva(const char* format, va_list args);
BCTBX_PUBLIC char* bc_sprintf(const char* format, ...);
BCTBX_PUBLIC void bc_free(void *ptr);
BCTBX_PUBLIC char * bc_tester_get_failed_asserts(void);
BCTBX_PUBLIC unsigned int bc_get_number_of_failures(void);
BCTBX_PUBLIC void bc_set_trace_handler(void(*handler)(int, const char*, va_list));
/**
* Get full path to the given resource
*
* @param name relative resource path
* @return path to the resource. Must be freed by caller.
*/
BCTBX_PUBLIC char * bc_tester_res(const char *name);
/**
* Get full path to the given writable_file
*
* @param name relative writable file path
* @return path to the writable file. Must be freed by caller.
*/
BCTBX_PUBLIC char * bc_tester_file(const char *name);
/*Redefine the CU_... macros WITHOUT final ';' semicolon, to allow IF conditions and smarter error message */
extern int CU_assertImplementation(int bValue,
unsigned int uiLine,
const char *strCondition,
const char *strFile,
const char *strFunction,
int bFatal);
/**
* Test unit assertion
*
* @return 1 if assert was true, 0 otherwise
*/
BCTBX_PUBLIC int bc_assert(const char* file, int line, int predicate, const char* format);
#define _BC_ASSERT_PRED(name, pred, actual, expected, type, ...) \
do { \
char format[4096] = {0}; \
type cactual = (actual); \
type cexpected = (expected); \
snprintf(format, 4096, name "(" #actual ", " #expected ") - " __VA_ARGS__); \
bc_assert(__FILE__, __LINE__, pred, format); \
} while (0)
#define BC_PASS(msg) bc_assert(__FILE__, __LINE__, TRUE, "BC_PASS(" #msg ").")
#define BC_FAIL(msg) bc_assert(__FILE__, __LINE__, FALSE, "BC_FAIL(" #msg ").")
#define BC_ASSERT(value) bc_assert(__FILE__, __LINE__, (value), #value)
#define BC_TEST(value) bc_assert(__FILE__, __LINE__, (value), #value)
#define BC_ASSERT_TRUE(value) bc_assert(__FILE__, __LINE__, (value), "BC_ASSERT_TRUE(" #value ")")
#define BC_ASSERT_FALSE(value) bc_assert(__FILE__, __LINE__, !(value), "BC_ASSERT_FALSE(" #value ")")
#define BC_ASSERT_PTR_EQUAL(actual, expected) bc_assert(__FILE__, __LINE__, ((actual) == (expected)), "BC_ASSERT_PTR_EQUAL(" #actual "!=" #expected ")")
#define BC_ASSERT_PTR_NOT_EQUAL(actual, expected) bc_assert(__FILE__, __LINE__, ((actual) != (expected)), "BC_ASSERT_PTR_NOT_EQUAL(" #actual "==" #expected ")")
#define BC_ASSERT_PTR_NULL(value) bc_assert(__FILE__, __LINE__, ((value) == NULL), "BC_ASSERT_PTR_NULL(" #value ")")
#define BC_ASSERT_PTR_NOT_NULL(value) bc_assert(__FILE__, __LINE__, ((value) != NULL), "BC_ASSERT_PTR_NOT_NULL(" #value ")")
#define BC_ASSERT_STRING_NOT_EQUAL(actual, expected) _BC_ASSERT_PRED("BC_ASSERT_STRING_NOT_EQUAL", (strcmp((const char*)(cactual), (const char*)(cexpected))), actual, expected, const char*, "Expected NOT %s but it was.", cexpected)
#define BC_ASSERT_NSTRING_EQUAL(actual, expected, count) _BC_ASSERT_PRED("BC_ASSERT_NSTRING_EQUAL", !(strncmp((const char*)(cactual), (const char*)(cexpected), (size_t)(count))), actual, expected, const char*, "Expected %*s but was %*s.", (int)(count), cexpected, (int)(count), cactual)
#define BC_ASSERT_NSTRING_NOT_EQUAL(actual, expected, count) _BC_ASSERT_PRED("BC_ASSERT_NSTRING_NOT_EQUAL", (strncmp((const char*)(cactual), (const char*)(cexpected), (size_t)(count))), actual, expected, const char*, "Expected %*s but it was.", (int)count, cexpected)
#define BC_ASSERT_DOUBLE_EQUAL(actual, expected, granularity) _BC_ASSERT_PRED("BC_ASSERT_DOUBLE_EQUAL", ((fabs((double)(cactual) - (cexpected)) <= fabs((double)(granularity)))), actual, expected, double, "Expected %f but was %f.", cexpected, cactual)
#define BC_ASSERT_DOUBLE_NOT_EQUAL(actual, expected, granularity) _BC_ASSERT_PRED("BC_ASSERT_DOUBLE_NOT_EQUAL", ((fabs((double)(cactual) - (cexpected)) > fabs((double)(granularity)))), actual, expected, double, "Expected %f but was %f.", cexpected, cactual)
#define BC_ASSERT_EQUAL(actual, expected, type, type_format) _BC_ASSERT_PRED("BC_ASSERT_EQUAL", ((cactual) == (cexpected)), actual, expected, type, "Expected " type_format " but was " type_format ".", cexpected, cactual)
#define BC_ASSERT_NOT_EQUAL(actual, expected, type, type_format) _BC_ASSERT_PRED("BC_ASSERT_NOT_EQUAL", ((cactual) != (cexpected)), actual, expected, type, "Expected NOT " type_format " but it was.", cexpected)
#define BC_ASSERT_STRING_EQUAL(actual, expected) _BC_ASSERT_PRED("BC_ASSERT_STRING_EQUAL", cactual && cexpected && !(strcmp((const char*)(cactual), (const char*)(cexpected))), actual, expected, const char*, "Expected %s but was %s.", cexpected, cactual)
#define BC_ASSERT_GREATER(actual, min, type, type_format) _BC_ASSERT_PRED("BC_ASSERT_GREATER", ((cactual) >= (cexpected)), actual, min, type, "Expected at least " type_format " but was " type_format ".", cexpected, cactual)
#define BC_ASSERT_LOWER(actual, max, type, type_format) _BC_ASSERT_PRED("BC_ASSERT_LOWER", ((cactual) <= (cexpected)), actual, max, type, "Expected at most " type_format " but was " type_format ".", cexpected, cactual)
#define BC_ASSERT_GREATER_STRICT(actual, min, type, type_format) _BC_ASSERT_PRED("BC_ASSERT_GREATER", ((cactual) > (cexpected)), actual, min, type, "Expected more than " type_format " but was " type_format ".", cexpected, cactual)
#define BC_ASSERT_LOWER_STRICT(actual, max, type, type_format) _BC_ASSERT_PRED("BC_ASSERT_LOWER", ((cactual) < (cexpected)), actual, max, type, "Expected less than " type_format " but was " type_format ".", cexpected, cactual)
#ifdef __cplusplus
}
#endif
#endif
bctoolbox-4.4.13/include/bctoolbox/vconnect.h 0000664 0000000 0000000 00000016514 13757173071 0021226 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_VCONNECT
#define BCTBX_VCONNECT
#include
#include
#if !defined(_WIN32_WCE)
#include
#include
#if _MSC_VER
#include
#endif
#endif /*_WIN32_WCE*/
#ifndef _WIN32
#include
#endif
#define BCTBX_VCONNECT_OK 0 /* Successful result */
#define BCTBX_VCONNECT_ERROR -255 /* Some kind of socket error occurred */
#ifdef __cplusplus
extern "C"{
#endif
/**
* Methods associated with the bctbx_vsocket_api_t.
*/
typedef struct bctbx_vsocket_methods_t bctbx_vsocket_methods_t;
/**
* Methods pointer prototypes for the socket functions.
*/
struct bctbx_vsocket_methods_t {
bctbx_socket_t (*pFuncSocket)(int socket_family, int socket_type, int protocol);
int (*pFuncConnect)(bctbx_socket_t sock, const struct sockaddr *address, socklen_t address_len);
int (*pFuncBind)(bctbx_socket_t sock, const struct sockaddr *address, socklen_t address_len);
int (*pFuncGetSockName)(bctbx_socket_t sockfd, struct sockaddr *addr, socklen_t *addrlen);
int (*pFuncGetSockOpt)(bctbx_socket_t sockfd, int level, int optname,
void *optval, socklen_t *optlen);
int (*pFuncSetSockOpt)(bctbx_socket_t sockfd, int level, int optname,
const void *optval, socklen_t optlen);
int (*pFuncClose)(bctbx_socket_t sock);
char* (*pFuncGetError)(int err);
int (*pFuncShutdown)(bctbx_socket_t sock, int how);
};
/**
* Socket API structure definition
*/
typedef struct bctbx_vsocket_api_t bctbx_vsocket_api_t;
struct bctbx_vsocket_api_t {
const char *vSockName; /* Socket API name */
const bctbx_vsocket_methods_t *pSocketMethods; /* Pointer to the socket methods structure */
};
/**===================================================
* Socket API methods prototypes.
* The default implementation relies on libc methods.
*====================================================*/
/**
* Creates a socket.
* @param socket_family type of address structure
* @param socket_type socket type i.e SOCK_STREAM
* @param protocol protocol family i.e AF_INET
* @return Returns a socket file descriptor.
*/
BCTBX_PUBLIC bctbx_socket_t bctbx_socket(int socket_family, int socket_type, int protocol);
/**
* Get the local socket address.
* Calls the function pointer pFuncGetSockName. The default method associated with this pointer
* is getsockname.
* @param sockfd socket descriptor
* @param addr buffer holding the current address to which the socket sockfd is bound
* @param addrlen amount of space (in bytes) pointed to by addr
* @return On success, zero is returned. On error, -1 is returned, and errno is
* set appropriately.
*/
BCTBX_PUBLIC int bctbx_getsockname(bctbx_socket_t sockfd, struct sockaddr *addr, socklen_t *addrlen);
/**
* Get socket options.
* @param sockfd socket file descriptor
* @param level level of the socket option
* @param optname name of the option
* @param optval buffer in which the value for the requested option(s) are to be returned
* @param optlen contains the size of the buffer pointed to by optval, and on return
* contains the actual size of the value returned.
* @return On success, zero is returned. On error, -1 is returned, and errno is
* set appropriately.
*/
BCTBX_PUBLIC int bctbx_getsockopt(bctbx_socket_t sockfd, int level, int optname,
void *optval, socklen_t *optlen);
/**
* Set socket options.
* @param sockfd socket file descriptor
* @param level level of the socket option
* @param optname name of the option
* @param optval buffer holding the value for the requested option
* @param optlen contains the size of the buffer pointed to by optval
* @return On success, zero is returned. On error, -1 is returned, and errno is
* set appropriately.
*/
BCTBX_PUBLIC int bctbx_setsockopt(bctbx_socket_t sockfd, int level, int optname,
const void *optval, socklen_t optlen);
/**
* Shut down part of a full duplex connection.
* @param sockfd socket file descriptor
* @param how specifies what is shut down in the connection.
* @return On success, zero is returned. On error, -1 is returned, and errno is
* set appropriately.
*/
BCTBX_PUBLIC int bctbx_shutdown(bctbx_socket_t sockfd, int how);
/**
* Close a socket file descriptor.
* @param sockfd socket file descriptor
* @return 0 on success , -1 on error and errno is set.
*/
BCTBX_PUBLIC int bctbx_socket_close(bctbx_socket_t sockfd);
/**
* Assign a name to a socket.
* @param sockfd socket file descriptor to assign the name to.
* @param address address of the socket
* @param address_len size of the address structure pointed to by address (bytes)
* @return On success, zero is returned. On error, -1 is returned, and errno is
* set appropriately.
*/
BCTBX_PUBLIC int bctbx_bind(bctbx_socket_t sockfd, const struct sockaddr *address, socklen_t address_len);
/**
* Initialize a connection to a socket.
* @param sockfd socket file descriptor
* @param address address of the socket
* @param address_len size of the address structure pointed to by address (bytes)
* @return On success, zero is returned. On error, -1 is returned, and errno is
* set appropriately.
*/
BCTBX_PUBLIC int bctbx_connect(bctbx_socket_t sockfd, const struct sockaddr *address, socklen_t address_len);
/**
* strerror equivalent.
* When an error is returned on a socket operations, returns
* the error description based on err (errno) value.
* @param err should be set to errno
* @return Error description
*/
BCTBX_PUBLIC char* bctbx_socket_error(int err);
/**
* Set default bctbx_vsocket_api_t pointer pDefaultvSocket to my_vsocket_api
* if it is not NULL, sets it to the standard API implementation otherwise.
* By default, the global pointer is set to use bcvSocket implemented in vconnect.c
* @param my_vsocket_api Pointer to a bctbx_vsocket_api_t structure.
*/
BCTBX_PUBLIC void bctbx_vsocket_api_set_default(bctbx_vsocket_api_t *my_vsocket_api);
/**
* Returns the value of the global variable pDefaultvSocket,
* pointing to the default bctbx_vsocket_api_t used.
* @return Pointer to bctbx_vsocket_api_t set to operate as default.
*/
BCTBX_PUBLIC bctbx_vsocket_api_t* bctbx_vsocket_api_get_default(void);
/**
* Return pointer to standard bctbx_vsocket_api_t implementation based on libc
* functions.
* @return pointer to bcSocketAPI
*/
BCTBX_PUBLIC bctbx_vsocket_api_t* bctbx_vsocket_api_get_standard(void);
#ifdef __cplusplus
}
#endif
#endif /* BCTBX_VCONNECT */
bctoolbox-4.4.13/include/bctoolbox/vfs.h 0000664 0000000 0000000 00000017067 13757173071 0020211 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifndef BCTBX_VFS_H
#define BCTBX_VFS_H
#include
#include
#if !defined(_WIN32_WCE)
#include
#include
#if _MSC_VER
#include
#endif
#endif /*_WIN32_WCE*/
#ifndef _WIN32
#include
#endif
#ifdef _WIN32
#ifndef S_IRUSR
#define S_IRUSR S_IREAD
#endif
#ifndef S_IWUSR
#define S_IWUSR S_IWRITE
#endif
#endif /*!_WIN32*/
#define BCTBX_VFS_OK 0 /* Successful result */
#define BCTBX_VFS_ERROR -255 /* Some kind of disk I/O error occurred */
#ifdef __cplusplus
extern "C"{
#endif
/**
* Methods associated with the bctbx_vfs_t.
*/
typedef struct bctbx_io_methods_t bctbx_io_methods_t;
/**
* VFS file handle.
*/
typedef struct bctbx_vfs_file_t bctbx_vfs_file_t;
struct bctbx_vfs_file_t {
const struct bctbx_io_methods_t *pMethods; /* Methods for an open file: all Developpers must supply this field at open step*/
/*the fields below are used by the default implementation. Developpers are not required to supply them, but may use them if they find
* them useful*/
void* pUserData; /*Developpers can store private data under this pointer */
int fd; /* File descriptor */
off_t offset; /*File offset used by lseek*/
};
/**
*/
struct bctbx_io_methods_t {
int (*pFuncClose)(bctbx_vfs_file_t *pFile);
ssize_t (*pFuncRead)(bctbx_vfs_file_t *pFile, void* buf, size_t count, off_t offset);
ssize_t (*pFuncWrite)(bctbx_vfs_file_t *pFile, const void* buf, size_t count, off_t offset);
int (*pFuncTruncate)(bctbx_vfs_file_t *pFile, int64_t size);
int64_t (*pFuncFileSize)(bctbx_vfs_file_t *pFile);
int (*pFuncGetLineFromFd)(bctbx_vfs_file_t *pFile, char* s, int count);
off_t (*pFuncSeek)(bctbx_vfs_file_t *pFile, off_t offset, int whence);
};
/**
* VFS definition
*/
typedef struct bctbx_vfs_t bctbx_vfs_t;
struct bctbx_vfs_t {
const char *vfsName; /* Virtual file system name */
int (*pFuncOpen)(bctbx_vfs_t *pVfs, bctbx_vfs_file_t *pFile, const char *fName, int openFlags);
};
/* API to use the VFS */
/*
* This function returns a pointer to the VFS implemented in this file.
*/
BCTBX_PUBLIC bctbx_vfs_t *bc_create_vfs(void);
/**
* Attempts to read count bytes from the open file given by pFile, at the position starting at offset
* in the file and and puts them in the buffer pointed by buf.
* @param pFile bctbx_vfs_file_t File handle pointer.
* @param buf Buffer holding the read bytes.
* @param count Number of bytes to read.
* @param offset Where to start reading in the file (in bytes).
* @return Number of bytes read on success, BCTBX_VFS_ERROR otherwise.
*/
BCTBX_PUBLIC ssize_t bctbx_file_read(bctbx_vfs_file_t *pFile, void *buf, size_t count, off_t offset);
/**
* Close the file from its descriptor pointed by thw bctbx_vfs_file_t handle.
* @param pFile File handle pointer.
* @return return value from the pFuncClose VFS Close function on success,
* BCTBX_VFS_ERROR otherwise.
*/
BCTBX_PUBLIC int bctbx_file_close(bctbx_vfs_file_t *pFile);
/**
* Allocates a bctbx_vfs_file_t file handle pointer. Opens the file fName
* with the mode specified by the mode argument. Calls bctbx_file_open.
* @param pVfs Pointer to the vfs instance in use.
* @param fName Absolute file path.
* @param mode File access mode (char*).
* @return pointer to bctbx_vfs_file_t on success, NULL otherwise.
*/
BCTBX_PUBLIC bctbx_vfs_file_t* bctbx_file_open(bctbx_vfs_t *pVfs, const char *fName, const char *mode);
/**
* Allocates a bctbx_vfs_file_t file handle pointer. Opens the file fName
* with the mode specified by the mode argument. Calls bctbx_file_open.
* @param pVfs Pointer to the vfs instance in use.
* @param fName Absolute file path.
* @param openFlags File access flags(integer).
* @return pointer to bctbx_vfs_file_t on success, NULL otherwise.
*/
BCTBX_PUBLIC bctbx_vfs_file_t* bctbx_file_open2(bctbx_vfs_t *pVfs, const char *fName, const int openFlags);
/**
* Returns the file size.
* @param pFile bctbx_vfs_file_t File handle pointer.
* @return BCTBX_VFS_ERROR if an error occured, file size otherwise.
*/
BCTBX_PUBLIC int64_t bctbx_file_size(bctbx_vfs_file_t *pFile);
/**
* Truncates/ Extends a file.
* @param pFile bctbx_vfs_file_t File handle pointer.
* @param size New size of the file.
* @return BCTBX_VFS_ERROR if an error occured, 0 otherwise.
*/
BCTBX_PUBLIC int bctbx_file_truncate(bctbx_vfs_file_t *pFile, int64_t size);
/**
* Write count bytes contained in buf to a file associated with pFile at the position
* offset. Calls pFuncWrite (set to bc_Write by default).
* @param pFile File handle pointer.
* @param buf Buffer hodling the values to write.
* @param count Number of bytes to write to the file.
* @param offset Position in the file where to start writing.
* @return Number of bytes written on success, BCTBX_VFS_ERROR if an error occurred.
*/
BCTBX_PUBLIC ssize_t bctbx_file_write(bctbx_vfs_file_t *pFile, const void *buf, size_t count, off_t offset);
/**
* Writes to file.
* @param pFile File handle pointer.
* @param offset where to write in the file
* @param fmt format argument, similar to that of printf
* @return Number of bytes written if success, BCTBX_VFS_ERROR otherwise.
*/
BCTBX_PUBLIC ssize_t bctbx_file_fprintf(bctbx_vfs_file_t *pFile, off_t offset, const char *fmt, ...);
/**
* Wrapper to pFuncGetNxtLine. Returns a line with at most maxlen characters
* from the file associated to pFile and writes it into s.
* @param pFile File handle pointer.
* @param s Buffer where to store the read line.
* @param maxlen Number of characters to read to find a line in the file.
* @return BCTBX_VFS_ERROR if an error occurred, size of line read otherwise.
*/
BCTBX_PUBLIC int bctbx_file_get_nxtline(bctbx_vfs_file_t *pFile, char *s, int maxlen);
/**
* Wrapper to pFuncSeek VFS method call. Set the position to offset in the file.
* @param pFile File handle pointer.
* @param offset File offset where to set the position to.
* @param whence Either SEEK_SET, SEEK_CUR,SEEK_END
* @return BCTBX_VFS_ERROR on error, offset otherwise.
*/
BCTBX_PUBLIC off_t bctbx_file_seek(bctbx_vfs_file_t *pFile, off_t offset, int whence);
/**
* Set default VFS pointer pDefault to my_vfs.
* By default, the global pointer is set to use VFS implemnted in vfs.c
* @param my_vfs Pointer to a bctbx_vfs_t structure.
*/
BCTBX_PUBLIC void bctbx_vfs_set_default(bctbx_vfs_t *my_vfs);
/**
* Returns the value of the global variable pDefault,
* pointing to the default vfs used.
* @return Pointer to bctbx_vfs_t set to operate as default VFS.
*/
BCTBX_PUBLIC bctbx_vfs_t* bctbx_vfs_get_default(void);
/**
* Return pointer to standard VFS impletentation.
* @return pointer to bcVfs
*/
BCTBX_PUBLIC bctbx_vfs_t* bctbx_vfs_get_standard(void);
#ifdef __cplusplus
}
#endif
#endif /* BCTBX_VFS_H */
bctoolbox-4.4.13/src/ 0000775 0000000 0000000 00000000000 13757173071 0014400 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/src/CMakeLists.txt 0000664 0000000 0000000 00000026521 13757173071 0017146 0 ustar 00root root 0000000 0000000 ############################################################################
# CMakeLists.txt
# Copyright (C) 2016 Belledonne Communications, Grenoble France
#
############################################################################
#
# 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 2
# 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.
#
############################################################################
set(BCTOOLBOX_C_SOURCE_FILES
containers/list.c
logging/logging.c
parser.c
utils/port.c
vconnect.c
vfs.c
)
set(BCTOOLBOX_CXX_SOURCE_FILES
containers/map.cc
conversion/charconv_encoding.cc
utils/exception.cc
utils/regex.cc
)
if(APPLE)
set(BCTOOLBOX_OBJC_SOURCE_FILES
utils/ios_utils.mm
)
set(BCTOOLBOX_IOS_OBJC_SOURCE_FILES
utils/ios_utils_app.mm
)
endif()
if(ANDROID)
list(APPEND BCTOOLBOX_CXX_SOURCE_FILES conversion/charconv_android.cc)
elseif(WIN32)
list(APPEND BCTOOLBOX_CXX_SOURCE_FILES conversion/charconv_windows.cc)
else()
list(APPEND BCTOOLBOX_CXX_SOURCE_FILES conversion/charconv.cc)
endif()
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
list(APPEND STRICT_OPTIONS_CXX "-x c++")
endif()
if(MBEDTLS_FOUND OR POLARSSL_FOUND)
list(APPEND BCTOOLBOX_C_SOURCE_FILES crypto/crypto.c)
list(APPEND BCTOOLBOX_CXX_SOURCE_FILES crypto/ecc.cc)
endif()
if(MBEDTLS_FOUND)
list(APPEND BCTOOLBOX_C_SOURCE_FILES crypto/mbedtls.c)
endif()
if(POLARSSL_FOUND)
list(APPEND BCTOOLBOX_C_SOURCE_FILES crypto/polarssl.c)
endif()
if(ENABLE_TESTS_COMPONENT)
set(BCTOOLBOX_C_TESTER_SOURCE_FILES tester.c)
endif()
set(BCTOOLBOX_SOURCE_FILES ${BCTOOLBOX_C_SOURCE_FILES} ${BCTOOLBOX_CXX_SOURCE_FILES} ${BCTOOLBOX_OBJC_SOURCE_FILES})
set(BCTOOLBOX_IOS_SOURCE_FILES ${BCTOOLBOX_IOS_OBJC_SOURCE_FILES})
set(BCTOOLBOX_TESTER_SOURCE_FILES ${BCTOOLBOX_C_TESTER_SOURCE_FILES})
bc_apply_compile_flags(BCTOOLBOX_C_SOURCE_FILES STRICT_OPTIONS_CPP STRICT_OPTIONS_C)
bc_apply_compile_flags(BCTOOLBOX_C_TESTER_SOURCE_FILES STRICT_OPTIONS_CPP STRICT_OPTIONS_C)
bc_apply_compile_flags(BCTOOLBOX_CXX_SOURCE_FILES STRICT_OPTIONS_CPP STRICT_OPTIONS_CXX)
bc_apply_compile_flags(BCTOOLBOX_OBJC_SOURCE_FILES STRICT_OPTIONS_CPP STRICT_OPTIONS_OBJC)
bc_apply_compile_flags(BCTOOLBOX_IOS_OBJC_SOURCE_FILES STRICT_OPTIONS_CPP STRICT_OPTIONS_OBJC)
if(ENABLE_STATIC)
add_library(bctoolbox-static STATIC ${BCTOOLBOX_SOURCE_FILES} ${BCTOOLBOX_HEADER_FILES})
target_link_libraries(bctoolbox-static INTERFACE ${CMAKE_THREAD_LIBS_INIT})
if(APPLE)
target_link_libraries(bctoolbox-static INTERFACE "-framework Foundation" "-framework AVFoundation")
target_include_directories(bctoolbox-static SYSTEM PRIVATE ${ICONV_INCLUDE_DIRS})
target_link_libraries(bctoolbox-static INTERFACE ${ICONV_LIBRARIES})
endif()
if(WIN32)
target_link_libraries(bctoolbox-static INTERFACE "Winmm" "Ws2_32")
endif()
set_target_properties(bctoolbox-static PROPERTIES LINKER_LANGUAGE "CXX")
if(NOT CMAKE_VERSION VERSION_LESS 3.1)
set_target_properties(bctoolbox-static PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON)
endif()
set_target_properties(bctoolbox-static PROPERTIES OUTPUT_NAME bctoolbox)
if(HAVE_LIBRT)
target_link_libraries(bctoolbox-static INTERFACE rt)
endif()
if(HAVE_LIBDL)
target_link_libraries(bctoolbox-static INTERFACE dl)
endif()
if(ANDROID)
target_link_libraries(bctoolbox-static INTERFACE log)
endif()
if(ENABLE_TESTS_COMPONENT)
add_library(bctoolbox-tester-static STATIC ${BCTOOLBOX_TESTER_SOURCE_FILES})
set_target_properties(bctoolbox-tester-static PROPERTIES OUTPUT_NAME bctoolbox-tester)
target_link_libraries(bctoolbox-tester-static INTERFACE bctoolbox-static)
endif()
endif()
if(ENABLE_SHARED)
add_library(bctoolbox SHARED ${BCTOOLBOX_SOURCE_FILES} ${BCTOOLBOX_HEADER_FILES})
target_link_libraries(bctoolbox PRIVATE ${CMAKE_THREAD_LIBS_INIT})
if(APPLE)
if(IOS)
set(MIN_OS ${LINPHONE_IOS_DEPLOYMENT_TARGET})
else()
set(MIN_OS ${CMAKE_OSX_DEPLOYMENT_TARGET})
endif()
set_target_properties(bctoolbox PROPERTIES
FRAMEWORK TRUE
MACOSX_FRAMEWORK_IDENTIFIER org.linphone.bctoolbox
MACOSX_FRAMEWORK_INFO_PLIST "${CMAKE_SOURCE_DIR}/build/osx/Info.plist.in"
PUBLIC_HEADER "${BCTOOLBOX_HEADER_FILES}"
)
endif()
if(APPLE)
target_link_libraries(bctoolbox PRIVATE "-framework Foundation" "-framework AVFoundation")
target_include_directories(bctoolbox SYSTEM PRIVATE ${ICONV_INCLUDE_DIRS})
target_link_libraries(bctoolbox PRIVATE ${ICONV_LIBRARIES})
endif()
if(WIN32)
if(NOT CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
target_link_libraries(bctoolbox PRIVATE "Winmm" "Ws2_32")
endif()
target_compile_definitions(bctoolbox PRIVATE "-DBCTBX_EXPORTS")
endif()
set_target_properties(bctoolbox PROPERTIES LINKER_LANGUAGE "CXX")
if(NOT CMAKE_VERSION VERSION_LESS 3.1)
set_target_properties(bctoolbox PROPERTIES CXX_STANDARD 11 CXX_STANDARD_REQUIRED ON)
endif()
if(NOT ANDROID)
# Do not version shared library on Android
set_target_properties(bctoolbox PROPERTIES SOVERSION ${BCTOOLBOX_SO_VERSION})
endif()
if(MSVC)
if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/bctoolbox.pdb
DESTINATION ${CMAKE_INSTALL_BINDIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
endif()
endif()
if(HAVE_LIBRT)
target_link_libraries(bctoolbox PRIVATE rt)
endif()
if(HAVE_LIBDL)
target_link_libraries(bctoolbox PRIVATE dl)
endif()
if(ANDROID)
target_link_libraries(bctoolbox PRIVATE log)
endif()
if(ENABLE_TESTS_COMPONENT)
add_library(bctoolbox-tester SHARED ${BCTOOLBOX_TESTER_SOURCE_FILES})
set_target_properties(bctoolbox-tester PROPERTIES LINKER_LANGUAGE "CXX")
target_link_libraries(bctoolbox-tester PUBLIC bctoolbox PRIVATE ${BCUNIT_TARGETNAME})
if(WIN32)
target_compile_definitions(bctoolbox-tester PRIVATE "-DBCTBX_EXPORTS")
endif()
if(NOT ANDROID)
# Do not version shared library on Android
set_target_properties(bctoolbox-tester PROPERTIES SOVERSION ${BCTOOLBOXTESTER_SO_VERSION})
endif()
if(MSVC)
if(CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/bctoolbox-tester.pdb
DESTINATION ${CMAKE_INSTALL_BINDIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
)
endif()
endif()
endif()
endif()
if(ENABLE_STATIC)
target_include_directories(bctoolbox-static PUBLIC
$
$
)
endif()
if(ENABLE_SHARED)
target_include_directories(bctoolbox PUBLIC
$
$
)
endif()
if(APPLE)
if(IOS)
add_library(bctoolbox-ios SHARED ${BCTOOLBOX_IOS_SOURCE_FILES})
target_link_libraries(bctoolbox-ios PRIVATE bctoolbox)
set_target_properties(bctoolbox-ios PROPERTIES
FRAMEWORK TRUE
MACOSX_FRAMEWORK_IDENTIFIER org.linphone.bctoolbox-ios
MACOSX_FRAMEWORK_INFO_PLIST "${CMAKE_SOURCE_DIR}/build/osx/Info.plist.in"
LINK_FLAGS "-framework UIKit -framework Foundation -framework CoreFoundation"
)
endif()
endif()
if(MBEDTLS_FOUND)
if(ENABLE_STATIC)
target_include_directories(bctoolbox-static SYSTEM PRIVATE ${MBEDTLS_INCLUDE_DIRS})
target_link_libraries(bctoolbox-static INTERFACE ${MBEDTLS_LIBRARIES})
endif()
if(ENABLE_SHARED)
target_include_directories(bctoolbox SYSTEM PRIVATE ${MBEDTLS_INCLUDE_DIRS})
target_link_libraries(bctoolbox PRIVATE ${MBEDTLS_LIBRARIES})
endif()
endif()
if(POLARSSL_FOUND)
if(ENABLE_STATIC)
target_include_directories(bctoolbox-static SYSTEM PRIVATE ${POLARSSL_INCLUDE_DIRS})
target_link_libraries(bctoolbox-static INTERFACE ${POLARSSL_LIBRARIES})
endif()
if(ENABLE_SHARED)
target_include_directories(bctoolbox PRIVATE ${POLARSSL_INCLUDE_DIRS})
target_link_libraries(bctoolbox PRIVATE ${POLARSSL_LIBRARIES})
endif()
endif()
if(DECAF_FOUND)
if(ENABLE_STATIC)
target_include_directories(bctoolbox-static PRIVATE ${DECAF_INCLUDE_DIRS})
target_link_libraries(bctoolbox-static PUBLIC decaf-static)
endif()
if(ENABLE_SHARED)
target_include_directories(bctoolbox PRIVATE ${DECAF_INCLUDE_DIRS})
target_link_libraries(bctoolbox PRIVATE ${DECAF_TARGETNAME})
endif()
endif()
if(ENABLE_TESTS_COMPONENT)
if(ENABLE_STATIC)
target_link_libraries(bctoolbox-tester-static PUBLIC bctoolbox-static ${BCUNIT_TARGETNAME})
endif()
if(ENABLE_SHARED)
if(APPLE)
set_target_properties(bctoolbox-tester PROPERTIES
FRAMEWORK TRUE
MACOSX_FRAMEWORK_IDENTIFIER com.belledonne-communications.bctoolbox-tester
MACOSX_FRAMEWORK_INFO_PLIST "${CMAKE_SOURCE_DIR}/build/osx/Info.plist.in"
PUBLIC_HEADER "${BCTOOLBOX_HEADER_FILES}"
)
endif()
endif()
endif()
if(ENABLE_STATIC)
install(TARGETS bctoolbox-static EXPORT ${EXPORT_TARGETS_NAME}Targets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
COMPONENT core
)
if(ENABLE_TESTS_COMPONENT)
install(TARGETS bctoolbox-tester-static EXPORT ${EXPORT_TARGETS_NAME}Targets
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
COMPONENT tester
)
endif()
endif()
if(ENABLE_SHARED)
install(TARGETS bctoolbox EXPORT ${EXPORT_TARGETS_NAME}Targets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
FRAMEWORK DESTINATION Frameworks
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
COMPONENT core
)
if(ENABLE_TESTS_COMPONENT)
install(TARGETS bctoolbox-tester EXPORT ${EXPORT_TARGETS_NAME}Targets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
FRAMEWORK DESTINATION Frameworks
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
COMPONENT tester
)
endif()
endif()
if(APPLE)
if(IOS)
install(TARGETS bctoolbox-ios EXPORT ${EXPORT_TARGETS_NAME}Targets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
FRAMEWORK DESTINATION Frameworks
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
COMPONENT core
)
endif()
endif()
if(MSVC)
# Disable "was deprecated" warnings of windows compiler (typically using strcpy_s instead of strcpy and stupid things like this).
if(ENABLE_SHARED)
target_compile_options(bctoolbox PRIVATE "/wd4996")
endif()
if(ENABLE_STATIC)
target_compile_options(bctoolbox-static PRIVATE "/wd4996")
endif()
if(ENABLE_TESTS_COMPONENT)
target_compile_options(bctoolbox-tester PRIVATE "/wd4996")
endif()
endif()
bctoolbox-4.4.13/src/containers/ 0000775 0000000 0000000 00000000000 13757173071 0016545 5 ustar 00root root 0000000 0000000 bctoolbox-4.4.13/src/containers/list.c 0000664 0000000 0000000 00000020673 13757173071 0017674 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#define _CRT_RAND_S
#include
#include
#include
#ifndef _WIN32
#include
#include /*for gettimeofday*/
#include /* available on POSIX system only */
#else
#include
#endif
#include "bctoolbox/port.h"
#include "bctoolbox/logging.h"
#include "bctoolbox/list.h"
bctbx_list_t* bctbx_list_new(void *data){
bctbx_list_t* new_elem=bctbx_new0(bctbx_list_t,1);
new_elem->data=data;
return new_elem;
}
bctbx_list_t* bctbx_list_next(const bctbx_list_t *elem) {
return elem->next;
}
void* bctbx_list_get_data(const bctbx_list_t *elem) {
return elem->data;
}
bctbx_list_t* bctbx_list_append_link(bctbx_list_t* elem,bctbx_list_t *new_elem){
bctbx_list_t* it=elem;
if (elem==NULL) return new_elem;
if (new_elem==NULL) return elem;
while (it->next!=NULL) it=bctbx_list_next(it);
it->next=new_elem;
new_elem->prev=it;
return elem;
}
bctbx_list_t* bctbx_list_append(bctbx_list_t* elem, void * data){
bctbx_list_t* new_elem=bctbx_list_new(data);
return bctbx_list_append_link(elem,new_elem);
}
bctbx_list_t* bctbx_list_prepend_link(bctbx_list_t* elem, bctbx_list_t *new_elem){
if (elem!=NULL) {
new_elem->next=elem;
elem->prev=new_elem;
}
return new_elem;
}
bctbx_list_t* bctbx_list_prepend(bctbx_list_t* elem, void *data){
return bctbx_list_prepend_link(elem,bctbx_list_new(data));
}
bctbx_list_t * bctbx_list_last_elem(const bctbx_list_t *l){
if (l==NULL) return NULL;
while(l->next){
l=l->next;
}
return (bctbx_list_t*)l;
}
bctbx_list_t * bctbx_list_first_elem(const bctbx_list_t *l){
if (l==NULL) return NULL;
while(l->prev){
l=l->prev;
}
return (bctbx_list_t*)l;
}
bctbx_list_t* bctbx_list_concat(bctbx_list_t* first, bctbx_list_t* second){
bctbx_list_t* it=first;
if (it==NULL) return second;
if (second==NULL) return first;
while(it->next!=NULL) it=bctbx_list_next(it);
it->next=second;
second->prev=it;
return first;
}
bctbx_list_t* bctbx_list_free(bctbx_list_t* list){
bctbx_list_t* elem = list;
bctbx_list_t* tmp;
if (list==NULL) return NULL;
while(elem->next!=NULL) {
tmp = elem;
elem = elem->next;
bctbx_free(tmp);
}
bctbx_free(elem);
return NULL;
}
bctbx_list_t * bctbx_list_free_with_data(bctbx_list_t *list, bctbx_list_free_func freefunc){
bctbx_list_t* elem = list;
bctbx_list_t* tmp;
if (list==NULL) return NULL;
while(elem->next!=NULL) {
tmp = elem;
elem = elem->next;
freefunc(tmp->data);
bctbx_free(tmp);
}
freefunc(elem->data);
bctbx_free(elem);
return NULL;
}
bctbx_list_t* _bctbx_list_remove(bctbx_list_t* first, void *data, int warn_if_not_found){
bctbx_list_t* it;
it=bctbx_list_find(first,data);
if (it) return bctbx_list_erase_link(first,it);
else if (warn_if_not_found){
bctbx_warning("bctbx_list_remove: no element with %p data was in the list", data);
}
return first;
}
bctbx_list_t* bctbx_list_remove(bctbx_list_t* first, void *data){
return _bctbx_list_remove(first, data, TRUE);
}
bctbx_list_t * bctbx_list_remove_custom(bctbx_list_t *first, bctbx_compare_func compare_func, const void *user_data) {
bctbx_list_t *cur;
bctbx_list_t *elem = first;
while (elem != NULL) {
cur = elem;
elem = elem->next;
if (compare_func(cur->data, user_data) == 0) {
first = bctbx_list_remove(first, cur->data);
}
}
return first;
}
size_t bctbx_list_size(const bctbx_list_t* first){
size_t n=0;
while(first!=NULL){
++n;
first=first->next;
}
return n;
}
void bctbx_list_for_each(const bctbx_list_t* list, bctbx_list_iterate_func func){
for(;list!=NULL;list=list->next){
func(list->data);
}
}
void bctbx_list_for_each2(const bctbx_list_t* list, bctbx_list_iterate2_func func, void *user_data){
for(;list!=NULL;list=list->next){
func(list->data,user_data);
}
}
bctbx_list_t * bctbx_list_pop_front(bctbx_list_t *list, void **front_data){
bctbx_list_t *front_elem=list;
if (front_elem==NULL){
*front_data=NULL;
return NULL;
}
*front_data=front_elem->data;
list=bctbx_list_unlink(list,front_elem);
bctbx_free(front_elem);
return list;
}
bctbx_list_t* bctbx_list_unlink(bctbx_list_t* list, bctbx_list_t* elem){
bctbx_list_t* ret;
if (elem==list){
ret=elem->next;
elem->prev=NULL;
elem->next=NULL;
if (ret!=NULL) ret->prev=NULL;
return ret;
}
elem->prev->next=elem->next;
if (elem->next!=NULL) elem->next->prev=elem->prev;
elem->next=NULL;
elem->prev=NULL;
return list;
}
bctbx_list_t * bctbx_list_erase_link(bctbx_list_t* list, bctbx_list_t* elem){
bctbx_list_t *ret=bctbx_list_unlink(list,elem);
bctbx_free(elem);
return ret;
}
bctbx_list_t* bctbx_list_find(bctbx_list_t* list, const void *data){
for(;list!=NULL;list=list->next){
if (list->data==data) return list;
}
return NULL;
}
bctbx_list_t* bctbx_list_find_custom(const bctbx_list_t* list, bctbx_compare_func compare_func, const void *user_data){
for(;list!=NULL;list=list->next){
if (compare_func(list->data,user_data)==0) return (bctbx_list_t *)list;
}
return NULL;
}
bctbx_list_t *bctbx_list_delete_custom(bctbx_list_t *list, bctbx_compare_func compare_func, const void *user_data){
bctbx_list_t *elem=bctbx_list_find_custom(list,compare_func,user_data);
if (elem!=NULL){
list=bctbx_list_erase_link(list,elem);
}
return list;
}
void * bctbx_list_nth_data(const bctbx_list_t* list, int index){
int i;
for(i=0;list!=NULL;list=list->next,++i){
if (i==index) return list->data;
}
bctbx_error("bctbx_list_nth_data: no such index in list.");
return NULL;
}
int bctbx_list_position(const bctbx_list_t* list, bctbx_list_t* elem){
int i;
for(i=0;list!=NULL;list=list->next,++i){
if (elem==list) return i;
}
bctbx_error("bctbx_list_position: no such element in list.");
return -1;
}
int bctbx_list_index(const bctbx_list_t* list, void *data){
int i;
for(i=0;list!=NULL;list=list->next,++i){
if (data==list->data) return i;
}
bctbx_error("bctbx_list_index: no such element in list.");
return -1;
}
bctbx_list_t* bctbx_list_insert_sorted(bctbx_list_t* list, void *data, bctbx_compare_func compare_func){
bctbx_list_t* it,*previt=NULL;
bctbx_list_t* nelem;
bctbx_list_t* ret=list;
if (list==NULL) return bctbx_list_append(list,data);
else{
nelem=bctbx_list_new(data);
for(it=list;it!=NULL;it=it->next){
previt=it;
if (compare_func(data,it->data)<=0){
nelem->prev=it->prev;
nelem->next=it;
if (it->prev!=NULL)
it->prev->next=nelem;
else{
ret=nelem;
}
it->prev=nelem;
return ret;
}
}
previt->next=nelem;
nelem->prev=previt;
}
return ret;
}
bctbx_list_t* bctbx_list_insert(bctbx_list_t* list, bctbx_list_t* before, void *data){
bctbx_list_t* elem;
if (list==NULL || before==NULL) return bctbx_list_append(list,data);
for(elem=list;elem!=NULL;elem=bctbx_list_next(elem)){
if (elem==before){
if (elem->prev==NULL)
return bctbx_list_prepend(list,data);
else{
bctbx_list_t* nelem=bctbx_list_new(data);
nelem->prev=elem->prev;
nelem->next=elem;
elem->prev->next=nelem;
elem->prev=nelem;
}
}
}
return list;
}
bctbx_list_t* bctbx_list_copy(const bctbx_list_t* list){
bctbx_list_t* copy=NULL;
const bctbx_list_t* iter;
for(iter=list;iter!=NULL;iter=bctbx_list_next(iter)){
copy=bctbx_list_append(copy,iter->data);
}
return copy;
}
bctbx_list_t* bctbx_list_copy_with_data(const bctbx_list_t* list, bctbx_list_copy_func copyfunc){
bctbx_list_t* copy=NULL;
const bctbx_list_t* iter;
for(iter=list;iter!=NULL;iter=bctbx_list_next(iter)){
copy=bctbx_list_append(copy,copyfunc(iter->data));
}
return copy;
}
bctbx_list_t* bctbx_list_copy_reverse_with_data(const bctbx_list_t* list, bctbx_list_copy_func copyfunc){
bctbx_list_t* copy=NULL;
const bctbx_list_t* iter;
for(iter=list;iter!=NULL;iter=bctbx_list_next(iter)){
copy=bctbx_list_prepend(copy,copyfunc(iter->data));
}
return copy;
}
bctoolbox-4.4.13/src/containers/map.cc 0000664 0000000 0000000 00000027263 13757173071 0017643 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) 2016-2020 Belledonne Communications SARL.
*
* This file is part of bctoolbox.
*
* 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 .
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "bctoolbox/logging.h"
#include "bctoolbox/map.h"
#include