diff --git a/ BUILD.gn b/ BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..ca51477d99c0956843560d2d92a09366ffeffea8 --- /dev/null +++ b/ BUILD.gn @@ -0,0 +1,145 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import("//build/ohos.gni") + +config("libsoup_config") { + cflags = [ + "-DHAVE_CONFIG_H", + "-DUSE_SQLITE_SYMBOLS", + "-DG_LOG_DOMAIN=\"libsoup\"", + "-DLIBSOUP_COMPILATION", + "-Wno-sign-compare" + ] +} + +ohos_source_set("soup_dynamic") { + sources = [ + "//third_party/libsoup/libsoup/soup-address.c", + "//third_party/libsoup/libsoup/soup-auth-basic.c", + "//third_party/libsoup/libsoup/soup-auth.c", + "//third_party/libsoup/libsoup/soup-auth-digest.c", + "//third_party/libsoup/libsoup/soup-auth-domain-basic.c", + "//third_party/libsoup/libsoup/soup-auth-domain.c", + "//third_party/libsoup/libsoup/soup-auth-domain-digest.c", + "//third_party/libsoup/libsoup/soup-auth-manager.c", + "//third_party/libsoup/libsoup/soup-auth-negotiate.c", + "//third_party/libsoup/libsoup/soup-auth-ntlm.c", + "//third_party/libsoup/libsoup/soup-body-input-stream.c", + "//third_party/libsoup/libsoup/soup-body-output-stream.c", + #"//third_party/libsoup/libsoup/soup-brotli-decompressor.c", + "//third_party/libsoup/libsoup/soup-cache.c", + "//third_party/libsoup/libsoup/soup-cache-client-input-stream.c", + "//third_party/libsoup/libsoup/soup-cache-input-stream.c", + "//third_party/libsoup/libsoup/soup-client-input-stream.c", + "//third_party/libsoup/libsoup/soup-connection-auth.c", + "//third_party/libsoup/libsoup/soup-connection.c", + "//third_party/libsoup/libsoup/soup-content-decoder.c", + "//third_party/libsoup/libsoup/soup-content-processor.c", + "//third_party/libsoup/libsoup/soup-content-sniffer.c", + "//third_party/libsoup/libsoup/soup-content-sniffer-stream.c", + "//third_party/libsoup/libsoup/soup-converter-wrapper.c", + "//third_party/libsoup/libsoup/soup-cookie.c", + "//third_party/libsoup/libsoup/soup-cookie-jar.c", + "//third_party/libsoup/libsoup/soup-cookie-jar-db.c", + "//third_party/libsoup/libsoup/soup-cookie-jar-sqlite.c", + "//third_party/libsoup/libsoup/soup-cookie-jar-text.c", + "//third_party/libsoup/libsoup/soup-date.c", + "//third_party/libsoup/libsoup/soup-directory-input-stream.c", + "//third_party/libsoup/libsoup/soup-filter-input-stream.c", + "//third_party/libsoup/libsoup/soup-form.c", + "//third_party/libsoup/libsoup/soup-gnome-features.c", + "//third_party/libsoup/libsoup/soup-headers.c", + "//third_party/libsoup/libsoup/soup-hsts-enforcer.c", + "//third_party/libsoup/libsoup/soup-hsts-enforcer-db.c", + "//third_party/libsoup/libsoup/soup-hsts-policy.c", + "//third_party/libsoup/libsoup/soup-init.c", + "//third_party/libsoup/libsoup/soup-io-stream.c", + "//third_party/libsoup/libsoup/soup-logger.c", + "//third_party/libsoup/libsoup/soup-message-body.c", + "//third_party/libsoup/libsoup/soup-message.c", + "//third_party/libsoup/libsoup/soup-message-client-io.c", + "//third_party/libsoup/libsoup/soup-message-headers.c", + "//third_party/libsoup/libsoup/soup-message-io.c", + "//third_party/libsoup/libsoup/soup-message-queue.c", + "//third_party/libsoup/libsoup/soup-message-server-io.c", + "//third_party/libsoup/libsoup/soup-method.c", + "//third_party/libsoup/libsoup/soup-misc.c", + "//third_party/libsoup/libsoup/soup-multipart.c", + "//third_party/libsoup/libsoup/soup-multipart-input-stream.c", + "//third_party/libsoup/libsoup/soup-password-manager.c", + "//third_party/libsoup/libsoup/soup-password-manager-gnome.c", + "//third_party/libsoup/libsoup/soup-path-map.c", + "//third_party/libsoup/libsoup/soup-proxy-resolver.c", + "//third_party/libsoup/libsoup/soup-proxy-resolver-default.c", + "//third_party/libsoup/libsoup/soup-proxy-resolver-gnome.c", + "//third_party/libsoup/libsoup/soup-proxy-resolver-wrapper.c", + "//third_party/libsoup/libsoup/soup-proxy-uri-resolver.c", + "//third_party/libsoup/libsoup/soup-request.c", + "//third_party/libsoup/libsoup/soup-request-data.c", + "//third_party/libsoup/libsoup/soup-requester.c", + "//third_party/libsoup/libsoup/soup-request-file.c", + "//third_party/libsoup/libsoup/soup-request-http.c", + "//third_party/libsoup/libsoup/soup-server.c", + "//third_party/libsoup/libsoup/soup-session-async.c", + "//third_party/libsoup/libsoup/soup-session.c", + "//third_party/libsoup/libsoup/soup-session-feature.c", + "//third_party/libsoup/libsoup/soup-session-sync.c", + "//third_party/libsoup/libsoup/soup-socket.c", + "//third_party/libsoup/libsoup/soup-socket-properties.c", + "//third_party/libsoup/libsoup/soup-status.c", + "//third_party/libsoup/libsoup/soup-tld.c", + "//third_party/libsoup/libsoup/soup-uri.c", + "//third_party/libsoup/libsoup/soup-value-utils.c", + "//third_party/libsoup/libsoup/soup-version.c", + "//third_party/libsoup/libsoup/soup-websocket.c", + "//third_party/libsoup/libsoup/soup-websocket-connection.c", + "//third_party/libsoup/libsoup/soup-websocket-extension.c", + "//third_party/libsoup/libsoup/soup-websocket-extension-deflate.c", + "//third_party/libsoup/libsoup/soup-websocket-extension-manager.c", + "//third_party/libsoup/libsoup/soup-xmlrpc.c", + "//third_party/libsoup/libsoup/soup-xmlrpc-old.c", + "//third_party/libsoup/libsoup/soup-enum-types.c", + ] + + configs = [":libsoup_config"] + include_dirs = [ + "//third_party/libsoup", + "//third_party/libsoup/libsoup", + "//third_party/glib", + "//third_party/glib/glib", + "//third_party/glib/gmodule", + "//third_party/glib/gio", + "//third_party/sqlite/include", + "//third_party/gettext/gettext-runtime/intl", + "//third_party/zlib", + "//third_party/libxml2/include", + "//third_party/libpsl/include", + ] +} + +ohos_shared_library("libohossoup") { + deps = [ + ":soup_dynamic", + "//third_party/glib:glib", + "//third_party/glib:gobject", + "//third_party/glib:gio", + "//third_party/zlib:libz", + "//third_party/libxml2:xml2", + "//third_party/sqlite:sqlite", + "//third_party/libpsl:libpsl", + "//third_party/gettext:libintl", + ] + part_name = "multimedia_histreamer" + subsystem_name = "multimedia" +} \ No newline at end of file diff --git a/OAT.xml b/OAT.xml new file mode 100644 index 0000000000000000000000000000000000000000..aab4c1464eb27ff081011aac678d217b0b00db4c --- /dev/null +++ b/OAT.xml @@ -0,0 +1,98 @@ + + + + + + COPYING + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/README.OpenSource b/README.OpenSource new file mode 100644 index 0000000000000000000000000000000000000000..4b67659224fbf9138a8a16160512e1422f60cb1a --- /dev/null +++ b/README.OpenSource @@ -0,0 +1,24 @@ +# Copyright (c) 2021 Huawei Device Co., Ltd. +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +[ + { + "Name": "libsoup", + "License": "GNU LIBRARY GENERAL PUBLIC LICENSE Version 2", + "License File": "NOTICE", + "Owner": "lixin113@huawei.com", + "Version Number": "2.71.0", + "Upstream URL": "https://gitlab.gnome.org/GNOME/libsoup.git", + "Description": "libsoup is an HTTP client/server library for GNOME. It uses GObjects and the glib main loop, to integrate well with GNOME applications." + } +] \ No newline at end of file diff --git a/config.h b/config.h new file mode 100644 index 0000000000000000000000000000000000000000..6d575df903e30c6d9cb670fbbe937de6b94d74ea --- /dev/null +++ b/config.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ + +/* + * Autogenerated by the Meson build system. + * Do not edit, your changes will be lost. + */ + +#pragma once + +#define APACHE_HTTPD "/usr/sbin/apache2" + +#define APACHE_MODULE_DIR /usr/lib/apache2/modules + +#define APACHE_PHP_MODULE_FILE /usr/lib/apache2/modules/libphp7.2.so + +#define APACHE_SSL_MODULE_DIR /usr/lib/apache2/modules + +#define GETTEXT_PACKAGE "libsoup-2.4" + +#define HAVE_APACHE + +#define HAVE_GMTIME_R 1 + +#define IF_HAVE_MOD_UNIXD # + +#define IF_HAVE_PHP + +#define IF_HAVE_PHP_XMLRPC ; + +#define LOCALEDIR "/usr/local/share/locale" + +#define PACKAGE_VERSION "2.71.0" + +#define _SOUP_EXTERN __attribute__((visibility("default"))) extern + diff --git a/libsoup/soup-cookie-jar-db.c b/libsoup/soup-cookie-jar-db.c index 3e7a70723e72673514a37a3cb49b596f94a3285d..209fef12f8b59923a5e7d0a3357766ca37c56cd0 100644 --- a/libsoup/soup-cookie-jar-db.c +++ b/libsoup/soup-cookie-jar-db.c @@ -13,7 +13,12 @@ #include +// using the "sqlite3sym.h" in OHOS +#ifndef USE_SQLITE_SYMBOLS #include +#else +#include +#endif #include "soup-cookie-jar-db.h" #include "soup.h" diff --git a/libsoup/soup-enum-types.c b/libsoup/soup-enum-types.c new file mode 100644 index 0000000000000000000000000000000000000000..5db3b9fffa71bfbe45a83d8bfec1621f05ed8ec6 --- /dev/null +++ b/libsoup/soup-enum-types.c @@ -0,0 +1,773 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ +/* Generated data (by glib-mkenums) */ + +#include + +#define LIBSOUP_USE_UNSTABLE_REQUEST_API +#include + +#define C_ENUM(v) ((gint) v) +#define C_FLAGS(v) ((guint) v) + +/* enumerations from "soup-address.h" */ +GType +soup_address_family_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_ADDRESS_FAMILY_INVALID), "SOUP_ADDRESS_FAMILY_INVALID", "invalid" }, + { C_ENUM(SOUP_ADDRESS_FAMILY_IPV4), "SOUP_ADDRESS_FAMILY_IPV4", "ipv4" }, + { C_ENUM(SOUP_ADDRESS_FAMILY_IPV6), "SOUP_ADDRESS_FAMILY_IPV6", "ipv6" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupAddressFamily", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-cache.h" */ +GType +soup_cacheability_get_type (void) +{ + static gsize id = 0; + static const GFlagsValue values[] = { + { C_FLAGS(SOUP_CACHE_CACHEABLE), "SOUP_CACHE_CACHEABLE", "cacheable" }, + { C_FLAGS(SOUP_CACHE_UNCACHEABLE), "SOUP_CACHE_UNCACHEABLE", "uncacheable" }, + { C_FLAGS(SOUP_CACHE_INVALIDATES), "SOUP_CACHE_INVALIDATES", "invalidates" }, + { C_FLAGS(SOUP_CACHE_VALIDATES), "SOUP_CACHE_VALIDATES", "validates" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_flags_register_static ("SoupCacheability", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_cache_response_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_CACHE_RESPONSE_FRESH), "SOUP_CACHE_RESPONSE_FRESH", "fresh" }, + { C_ENUM(SOUP_CACHE_RESPONSE_NEEDS_VALIDATION), "SOUP_CACHE_RESPONSE_NEEDS_VALIDATION", "needs-validation" }, + { C_ENUM(SOUP_CACHE_RESPONSE_STALE), "SOUP_CACHE_RESPONSE_STALE", "stale" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupCacheResponse", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_cache_type_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_CACHE_SINGLE_USER), "SOUP_CACHE_SINGLE_USER", "single-user" }, + { C_ENUM(SOUP_CACHE_SHARED), "SOUP_CACHE_SHARED", "shared" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupCacheType", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-cookie.h" */ +GType +soup_same_site_policy_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_SAME_SITE_POLICY_NONE), "SOUP_SAME_SITE_POLICY_NONE", "none" }, + { C_ENUM(SOUP_SAME_SITE_POLICY_LAX), "SOUP_SAME_SITE_POLICY_LAX", "lax" }, + { C_ENUM(SOUP_SAME_SITE_POLICY_STRICT), "SOUP_SAME_SITE_POLICY_STRICT", "strict" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupSameSitePolicy", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-cookie-jar.h" */ +GType +soup_cookie_jar_accept_policy_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_COOKIE_JAR_ACCEPT_ALWAYS), "SOUP_COOKIE_JAR_ACCEPT_ALWAYS", "always" }, + { C_ENUM(SOUP_COOKIE_JAR_ACCEPT_NEVER), "SOUP_COOKIE_JAR_ACCEPT_NEVER", "never" }, + { C_ENUM(SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY), "SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY", "no-third-party" }, + { C_ENUM(SOUP_COOKIE_JAR_ACCEPT_GRANDFATHERED_THIRD_PARTY), "SOUP_COOKIE_JAR_ACCEPT_GRANDFATHERED_THIRD_PARTY", "grandfathered-third-party" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupCookieJarAcceptPolicy", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-date.h" */ +GType +soup_date_format_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_DATE_HTTP), "SOUP_DATE_HTTP", "http" }, + { C_ENUM(SOUP_DATE_COOKIE), "SOUP_DATE_COOKIE", "cookie" }, + { C_ENUM(SOUP_DATE_RFC2822), "SOUP_DATE_RFC2822", "rfc2822" }, + { C_ENUM(SOUP_DATE_ISO8601_COMPACT), "SOUP_DATE_ISO8601_COMPACT", "iso8601-compact" }, + { C_ENUM(SOUP_DATE_ISO8601_FULL), "SOUP_DATE_ISO8601_FULL", "iso8601-full" }, + { C_ENUM(SOUP_DATE_ISO8601), "SOUP_DATE_ISO8601", "iso8601" }, + { C_ENUM(SOUP_DATE_ISO8601_XMLRPC), "SOUP_DATE_ISO8601_XMLRPC", "iso8601-xmlrpc" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupDateFormat", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-logger.h" */ +GType +soup_logger_log_level_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_LOGGER_LOG_NONE), "SOUP_LOGGER_LOG_NONE", "none" }, + { C_ENUM(SOUP_LOGGER_LOG_MINIMAL), "SOUP_LOGGER_LOG_MINIMAL", "minimal" }, + { C_ENUM(SOUP_LOGGER_LOG_HEADERS), "SOUP_LOGGER_LOG_HEADERS", "headers" }, + { C_ENUM(SOUP_LOGGER_LOG_BODY), "SOUP_LOGGER_LOG_BODY", "body" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupLoggerLogLevel", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-message.h" */ +GType +soup_http_version_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_HTTP_1_0), "SOUP_HTTP_1_0", "http-1-0" }, + { C_ENUM(SOUP_HTTP_1_1), "SOUP_HTTP_1_1", "http-1-1" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupHTTPVersion", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_message_flags_get_type (void) +{ + static gsize id = 0; + static const GFlagsValue values[] = { + { C_FLAGS(SOUP_MESSAGE_NO_REDIRECT), "SOUP_MESSAGE_NO_REDIRECT", "no-redirect" }, + { C_FLAGS(SOUP_MESSAGE_CAN_REBUILD), "SOUP_MESSAGE_CAN_REBUILD", "can-rebuild" }, + { C_FLAGS(SOUP_MESSAGE_OVERWRITE_CHUNKS), "SOUP_MESSAGE_OVERWRITE_CHUNKS", "overwrite-chunks" }, + { C_FLAGS(SOUP_MESSAGE_CONTENT_DECODED), "SOUP_MESSAGE_CONTENT_DECODED", "content-decoded" }, + { C_FLAGS(SOUP_MESSAGE_CERTIFICATE_TRUSTED), "SOUP_MESSAGE_CERTIFICATE_TRUSTED", "certificate-trusted" }, + { C_FLAGS(SOUP_MESSAGE_NEW_CONNECTION), "SOUP_MESSAGE_NEW_CONNECTION", "new-connection" }, + { C_FLAGS(SOUP_MESSAGE_IDEMPOTENT), "SOUP_MESSAGE_IDEMPOTENT", "idempotent" }, + { C_FLAGS(SOUP_MESSAGE_IGNORE_CONNECTION_LIMITS), "SOUP_MESSAGE_IGNORE_CONNECTION_LIMITS", "ignore-connection-limits" }, + { C_FLAGS(SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE), "SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE", "do-not-use-auth-cache" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_flags_register_static ("SoupMessageFlags", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_message_priority_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_MESSAGE_PRIORITY_VERY_LOW), "SOUP_MESSAGE_PRIORITY_VERY_LOW", "very-low" }, + { C_ENUM(SOUP_MESSAGE_PRIORITY_LOW), "SOUP_MESSAGE_PRIORITY_LOW", "low" }, + { C_ENUM(SOUP_MESSAGE_PRIORITY_NORMAL), "SOUP_MESSAGE_PRIORITY_NORMAL", "normal" }, + { C_ENUM(SOUP_MESSAGE_PRIORITY_HIGH), "SOUP_MESSAGE_PRIORITY_HIGH", "high" }, + { C_ENUM(SOUP_MESSAGE_PRIORITY_VERY_HIGH), "SOUP_MESSAGE_PRIORITY_VERY_HIGH", "very-high" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupMessagePriority", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-message-body.h" */ +GType +soup_memory_use_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_MEMORY_STATIC), "SOUP_MEMORY_STATIC", "static" }, + { C_ENUM(SOUP_MEMORY_TAKE), "SOUP_MEMORY_TAKE", "take" }, + { C_ENUM(SOUP_MEMORY_COPY), "SOUP_MEMORY_COPY", "copy" }, + { C_ENUM(SOUP_MEMORY_TEMPORARY), "SOUP_MEMORY_TEMPORARY", "temporary" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupMemoryUse", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-message-headers.h" */ +GType +soup_message_headers_type_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_MESSAGE_HEADERS_REQUEST), "SOUP_MESSAGE_HEADERS_REQUEST", "request" }, + { C_ENUM(SOUP_MESSAGE_HEADERS_RESPONSE), "SOUP_MESSAGE_HEADERS_RESPONSE", "response" }, + { C_ENUM(SOUP_MESSAGE_HEADERS_MULTIPART), "SOUP_MESSAGE_HEADERS_MULTIPART", "multipart" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupMessageHeadersType", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_encoding_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_ENCODING_UNRECOGNIZED), "SOUP_ENCODING_UNRECOGNIZED", "unrecognized" }, + { C_ENUM(SOUP_ENCODING_NONE), "SOUP_ENCODING_NONE", "none" }, + { C_ENUM(SOUP_ENCODING_CONTENT_LENGTH), "SOUP_ENCODING_CONTENT_LENGTH", "content-length" }, + { C_ENUM(SOUP_ENCODING_EOF), "SOUP_ENCODING_EOF", "eof" }, + { C_ENUM(SOUP_ENCODING_CHUNKED), "SOUP_ENCODING_CHUNKED", "chunked" }, + { C_ENUM(SOUP_ENCODING_BYTERANGES), "SOUP_ENCODING_BYTERANGES", "byteranges" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupEncoding", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_expectation_get_type (void) +{ + static gsize id = 0; + static const GFlagsValue values[] = { + { C_FLAGS(SOUP_EXPECTATION_UNRECOGNIZED), "SOUP_EXPECTATION_UNRECOGNIZED", "unrecognized" }, + { C_FLAGS(SOUP_EXPECTATION_CONTINUE), "SOUP_EXPECTATION_CONTINUE", "continue" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_flags_register_static ("SoupExpectation", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-misc.h" */ +GType +soup_connection_state_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_CONNECTION_NEW), "SOUP_CONNECTION_NEW", "new" }, + { C_ENUM(SOUP_CONNECTION_CONNECTING), "SOUP_CONNECTION_CONNECTING", "connecting" }, + { C_ENUM(SOUP_CONNECTION_IDLE), "SOUP_CONNECTION_IDLE", "idle" }, + { C_ENUM(SOUP_CONNECTION_IN_USE), "SOUP_CONNECTION_IN_USE", "in-use" }, + { C_ENUM(SOUP_CONNECTION_REMOTE_DISCONNECTED), "SOUP_CONNECTION_REMOTE_DISCONNECTED", "remote-disconnected" }, + { C_ENUM(SOUP_CONNECTION_DISCONNECTED), "SOUP_CONNECTION_DISCONNECTED", "disconnected" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupConnectionState", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-requester.h" */ +GType +soup_requester_error_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_REQUESTER_ERROR_BAD_URI), "SOUP_REQUESTER_ERROR_BAD_URI", "bad-uri" }, + { C_ENUM(SOUP_REQUESTER_ERROR_UNSUPPORTED_URI_SCHEME), "SOUP_REQUESTER_ERROR_UNSUPPORTED_URI_SCHEME", "unsupported-uri-scheme" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupRequesterError", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-server.h" */ +GType +soup_server_listen_options_get_type (void) +{ + static gsize id = 0; + static const GFlagsValue values[] = { + { C_FLAGS(SOUP_SERVER_LISTEN_HTTPS), "SOUP_SERVER_LISTEN_HTTPS", "https" }, + { C_FLAGS(SOUP_SERVER_LISTEN_IPV4_ONLY), "SOUP_SERVER_LISTEN_IPV4_ONLY", "ipv4-only" }, + { C_FLAGS(SOUP_SERVER_LISTEN_IPV6_ONLY), "SOUP_SERVER_LISTEN_IPV6_ONLY", "ipv6-only" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_flags_register_static ("SoupServerListenOptions", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-session.h" */ +GType +soup_request_error_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_REQUEST_ERROR_BAD_URI), "SOUP_REQUEST_ERROR_BAD_URI", "bad-uri" }, + { C_ENUM(SOUP_REQUEST_ERROR_UNSUPPORTED_URI_SCHEME), "SOUP_REQUEST_ERROR_UNSUPPORTED_URI_SCHEME", "unsupported-uri-scheme" }, + { C_ENUM(SOUP_REQUEST_ERROR_PARSING), "SOUP_REQUEST_ERROR_PARSING", "parsing" }, + { C_ENUM(SOUP_REQUEST_ERROR_ENCODING), "SOUP_REQUEST_ERROR_ENCODING", "encoding" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupRequestError", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-socket.h" */ +GType +soup_socket_io_status_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_SOCKET_OK), "SOUP_SOCKET_OK", "ok" }, + { C_ENUM(SOUP_SOCKET_WOULD_BLOCK), "SOUP_SOCKET_WOULD_BLOCK", "would-block" }, + { C_ENUM(SOUP_SOCKET_EOF), "SOUP_SOCKET_EOF", "eof" }, + { C_ENUM(SOUP_SOCKET_ERROR), "SOUP_SOCKET_ERROR", "error" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupSocketIOStatus", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-status.h" */ +GType +soup_status_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_STATUS_NONE), "SOUP_STATUS_NONE", "none" }, + { C_ENUM(SOUP_STATUS_CANCELLED), "SOUP_STATUS_CANCELLED", "cancelled" }, + { C_ENUM(SOUP_STATUS_CANT_RESOLVE), "SOUP_STATUS_CANT_RESOLVE", "cant-resolve" }, + { C_ENUM(SOUP_STATUS_CANT_RESOLVE_PROXY), "SOUP_STATUS_CANT_RESOLVE_PROXY", "cant-resolve-proxy" }, + { C_ENUM(SOUP_STATUS_CANT_CONNECT), "SOUP_STATUS_CANT_CONNECT", "cant-connect" }, + { C_ENUM(SOUP_STATUS_CANT_CONNECT_PROXY), "SOUP_STATUS_CANT_CONNECT_PROXY", "cant-connect-proxy" }, + { C_ENUM(SOUP_STATUS_SSL_FAILED), "SOUP_STATUS_SSL_FAILED", "ssl-failed" }, + { C_ENUM(SOUP_STATUS_IO_ERROR), "SOUP_STATUS_IO_ERROR", "io-error" }, + { C_ENUM(SOUP_STATUS_MALFORMED), "SOUP_STATUS_MALFORMED", "malformed" }, + { C_ENUM(SOUP_STATUS_TRY_AGAIN), "SOUP_STATUS_TRY_AGAIN", "try-again" }, + { C_ENUM(SOUP_STATUS_TOO_MANY_REDIRECTS), "SOUP_STATUS_TOO_MANY_REDIRECTS", "too-many-redirects" }, + { C_ENUM(SOUP_STATUS_TLS_FAILED), "SOUP_STATUS_TLS_FAILED", "tls-failed" }, + { C_ENUM(SOUP_STATUS_CONTINUE), "SOUP_STATUS_CONTINUE", "continue" }, + { C_ENUM(SOUP_STATUS_SWITCHING_PROTOCOLS), "SOUP_STATUS_SWITCHING_PROTOCOLS", "switching-protocols" }, + { C_ENUM(SOUP_STATUS_PROCESSING), "SOUP_STATUS_PROCESSING", "processing" }, + { C_ENUM(SOUP_STATUS_OK), "SOUP_STATUS_OK", "ok" }, + { C_ENUM(SOUP_STATUS_CREATED), "SOUP_STATUS_CREATED", "created" }, + { C_ENUM(SOUP_STATUS_ACCEPTED), "SOUP_STATUS_ACCEPTED", "accepted" }, + { C_ENUM(SOUP_STATUS_NON_AUTHORITATIVE), "SOUP_STATUS_NON_AUTHORITATIVE", "non-authoritative" }, + { C_ENUM(SOUP_STATUS_NO_CONTENT), "SOUP_STATUS_NO_CONTENT", "no-content" }, + { C_ENUM(SOUP_STATUS_RESET_CONTENT), "SOUP_STATUS_RESET_CONTENT", "reset-content" }, + { C_ENUM(SOUP_STATUS_PARTIAL_CONTENT), "SOUP_STATUS_PARTIAL_CONTENT", "partial-content" }, + { C_ENUM(SOUP_STATUS_MULTI_STATUS), "SOUP_STATUS_MULTI_STATUS", "multi-status" }, + { C_ENUM(SOUP_STATUS_MULTIPLE_CHOICES), "SOUP_STATUS_MULTIPLE_CHOICES", "multiple-choices" }, + { C_ENUM(SOUP_STATUS_MOVED_PERMANENTLY), "SOUP_STATUS_MOVED_PERMANENTLY", "moved-permanently" }, + { C_ENUM(SOUP_STATUS_FOUND), "SOUP_STATUS_FOUND", "found" }, + { C_ENUM(SOUP_STATUS_MOVED_TEMPORARILY), "SOUP_STATUS_MOVED_TEMPORARILY", "moved-temporarily" }, + { C_ENUM(SOUP_STATUS_SEE_OTHER), "SOUP_STATUS_SEE_OTHER", "see-other" }, + { C_ENUM(SOUP_STATUS_NOT_MODIFIED), "SOUP_STATUS_NOT_MODIFIED", "not-modified" }, + { C_ENUM(SOUP_STATUS_USE_PROXY), "SOUP_STATUS_USE_PROXY", "use-proxy" }, + { C_ENUM(SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL), "SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL", "not-appearing-in-this-protocol" }, + { C_ENUM(SOUP_STATUS_TEMPORARY_REDIRECT), "SOUP_STATUS_TEMPORARY_REDIRECT", "temporary-redirect" }, + { C_ENUM(SOUP_STATUS_BAD_REQUEST), "SOUP_STATUS_BAD_REQUEST", "bad-request" }, + { C_ENUM(SOUP_STATUS_UNAUTHORIZED), "SOUP_STATUS_UNAUTHORIZED", "unauthorized" }, + { C_ENUM(SOUP_STATUS_PAYMENT_REQUIRED), "SOUP_STATUS_PAYMENT_REQUIRED", "payment-required" }, + { C_ENUM(SOUP_STATUS_FORBIDDEN), "SOUP_STATUS_FORBIDDEN", "forbidden" }, + { C_ENUM(SOUP_STATUS_NOT_FOUND), "SOUP_STATUS_NOT_FOUND", "not-found" }, + { C_ENUM(SOUP_STATUS_METHOD_NOT_ALLOWED), "SOUP_STATUS_METHOD_NOT_ALLOWED", "method-not-allowed" }, + { C_ENUM(SOUP_STATUS_NOT_ACCEPTABLE), "SOUP_STATUS_NOT_ACCEPTABLE", "not-acceptable" }, + { C_ENUM(SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED), "SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED", "proxy-authentication-required" }, + { C_ENUM(SOUP_STATUS_PROXY_UNAUTHORIZED), "SOUP_STATUS_PROXY_UNAUTHORIZED", "proxy-unauthorized" }, + { C_ENUM(SOUP_STATUS_REQUEST_TIMEOUT), "SOUP_STATUS_REQUEST_TIMEOUT", "request-timeout" }, + { C_ENUM(SOUP_STATUS_CONFLICT), "SOUP_STATUS_CONFLICT", "conflict" }, + { C_ENUM(SOUP_STATUS_GONE), "SOUP_STATUS_GONE", "gone" }, + { C_ENUM(SOUP_STATUS_LENGTH_REQUIRED), "SOUP_STATUS_LENGTH_REQUIRED", "length-required" }, + { C_ENUM(SOUP_STATUS_PRECONDITION_FAILED), "SOUP_STATUS_PRECONDITION_FAILED", "precondition-failed" }, + { C_ENUM(SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE), "SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE", "request-entity-too-large" }, + { C_ENUM(SOUP_STATUS_REQUEST_URI_TOO_LONG), "SOUP_STATUS_REQUEST_URI_TOO_LONG", "request-uri-too-long" }, + { C_ENUM(SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE), "SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE", "unsupported-media-type" }, + { C_ENUM(SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE), "SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE", "requested-range-not-satisfiable" }, + { C_ENUM(SOUP_STATUS_INVALID_RANGE), "SOUP_STATUS_INVALID_RANGE", "invalid-range" }, + { C_ENUM(SOUP_STATUS_EXPECTATION_FAILED), "SOUP_STATUS_EXPECTATION_FAILED", "expectation-failed" }, + { C_ENUM(SOUP_STATUS_UNPROCESSABLE_ENTITY), "SOUP_STATUS_UNPROCESSABLE_ENTITY", "unprocessable-entity" }, + { C_ENUM(SOUP_STATUS_LOCKED), "SOUP_STATUS_LOCKED", "locked" }, + { C_ENUM(SOUP_STATUS_FAILED_DEPENDENCY), "SOUP_STATUS_FAILED_DEPENDENCY", "failed-dependency" }, + { C_ENUM(SOUP_STATUS_INTERNAL_SERVER_ERROR), "SOUP_STATUS_INTERNAL_SERVER_ERROR", "internal-server-error" }, + { C_ENUM(SOUP_STATUS_NOT_IMPLEMENTED), "SOUP_STATUS_NOT_IMPLEMENTED", "not-implemented" }, + { C_ENUM(SOUP_STATUS_BAD_GATEWAY), "SOUP_STATUS_BAD_GATEWAY", "bad-gateway" }, + { C_ENUM(SOUP_STATUS_SERVICE_UNAVAILABLE), "SOUP_STATUS_SERVICE_UNAVAILABLE", "service-unavailable" }, + { C_ENUM(SOUP_STATUS_GATEWAY_TIMEOUT), "SOUP_STATUS_GATEWAY_TIMEOUT", "gateway-timeout" }, + { C_ENUM(SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED), "SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED", "http-version-not-supported" }, + { C_ENUM(SOUP_STATUS_INSUFFICIENT_STORAGE), "SOUP_STATUS_INSUFFICIENT_STORAGE", "insufficient-storage" }, + { C_ENUM(SOUP_STATUS_NOT_EXTENDED), "SOUP_STATUS_NOT_EXTENDED", "not-extended" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupStatus", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_known_status_code_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NONE), "SOUP_KNOWN_STATUS_CODE_NONE", "none" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_CANCELLED), "SOUP_KNOWN_STATUS_CODE_CANCELLED", "cancelled" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_CANT_RESOLVE), "SOUP_KNOWN_STATUS_CODE_CANT_RESOLVE", "cant-resolve" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_CANT_RESOLVE_PROXY), "SOUP_KNOWN_STATUS_CODE_CANT_RESOLVE_PROXY", "cant-resolve-proxy" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_CANT_CONNECT), "SOUP_KNOWN_STATUS_CODE_CANT_CONNECT", "cant-connect" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_CANT_CONNECT_PROXY), "SOUP_KNOWN_STATUS_CODE_CANT_CONNECT_PROXY", "cant-connect-proxy" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_SSL_FAILED), "SOUP_KNOWN_STATUS_CODE_SSL_FAILED", "ssl-failed" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_IO_ERROR), "SOUP_KNOWN_STATUS_CODE_IO_ERROR", "io-error" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_MALFORMED), "SOUP_KNOWN_STATUS_CODE_MALFORMED", "malformed" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_TRY_AGAIN), "SOUP_KNOWN_STATUS_CODE_TRY_AGAIN", "try-again" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_TOO_MANY_REDIRECTS), "SOUP_KNOWN_STATUS_CODE_TOO_MANY_REDIRECTS", "too-many-redirects" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_TLS_FAILED), "SOUP_KNOWN_STATUS_CODE_TLS_FAILED", "tls-failed" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_CONTINUE), "SOUP_KNOWN_STATUS_CODE_CONTINUE", "continue" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_SWITCHING_PROTOCOLS), "SOUP_KNOWN_STATUS_CODE_SWITCHING_PROTOCOLS", "switching-protocols" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_PROCESSING), "SOUP_KNOWN_STATUS_CODE_PROCESSING", "processing" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_OK), "SOUP_KNOWN_STATUS_CODE_OK", "ok" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_CREATED), "SOUP_KNOWN_STATUS_CODE_CREATED", "created" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_ACCEPTED), "SOUP_KNOWN_STATUS_CODE_ACCEPTED", "accepted" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NON_AUTHORITATIVE), "SOUP_KNOWN_STATUS_CODE_NON_AUTHORITATIVE", "non-authoritative" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NO_CONTENT), "SOUP_KNOWN_STATUS_CODE_NO_CONTENT", "no-content" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_RESET_CONTENT), "SOUP_KNOWN_STATUS_CODE_RESET_CONTENT", "reset-content" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_PARTIAL_CONTENT), "SOUP_KNOWN_STATUS_CODE_PARTIAL_CONTENT", "partial-content" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_MULTI_STATUS), "SOUP_KNOWN_STATUS_CODE_MULTI_STATUS", "multi-status" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_MULTIPLE_CHOICES), "SOUP_KNOWN_STATUS_CODE_MULTIPLE_CHOICES", "multiple-choices" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_MOVED_PERMANENTLY), "SOUP_KNOWN_STATUS_CODE_MOVED_PERMANENTLY", "moved-permanently" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_FOUND), "SOUP_KNOWN_STATUS_CODE_FOUND", "found" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_MOVED_TEMPORARILY), "SOUP_KNOWN_STATUS_CODE_MOVED_TEMPORARILY", "moved-temporarily" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_SEE_OTHER), "SOUP_KNOWN_STATUS_CODE_SEE_OTHER", "see-other" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NOT_MODIFIED), "SOUP_KNOWN_STATUS_CODE_NOT_MODIFIED", "not-modified" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_USE_PROXY), "SOUP_KNOWN_STATUS_CODE_USE_PROXY", "use-proxy" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NOT_APPEARING_IN_THIS_PROTOCOL), "SOUP_KNOWN_STATUS_CODE_NOT_APPEARING_IN_THIS_PROTOCOL", "not-appearing-in-this-protocol" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_TEMPORARY_REDIRECT), "SOUP_KNOWN_STATUS_CODE_TEMPORARY_REDIRECT", "temporary-redirect" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_BAD_REQUEST), "SOUP_KNOWN_STATUS_CODE_BAD_REQUEST", "bad-request" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_UNAUTHORIZED), "SOUP_KNOWN_STATUS_CODE_UNAUTHORIZED", "unauthorized" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_PAYMENT_REQUIRED), "SOUP_KNOWN_STATUS_CODE_PAYMENT_REQUIRED", "payment-required" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_FORBIDDEN), "SOUP_KNOWN_STATUS_CODE_FORBIDDEN", "forbidden" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NOT_FOUND), "SOUP_KNOWN_STATUS_CODE_NOT_FOUND", "not-found" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_METHOD_NOT_ALLOWED), "SOUP_KNOWN_STATUS_CODE_METHOD_NOT_ALLOWED", "method-not-allowed" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NOT_ACCEPTABLE), "SOUP_KNOWN_STATUS_CODE_NOT_ACCEPTABLE", "not-acceptable" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_PROXY_AUTHENTICATION_REQUIRED), "SOUP_KNOWN_STATUS_CODE_PROXY_AUTHENTICATION_REQUIRED", "proxy-authentication-required" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_PROXY_UNAUTHORIZED), "SOUP_KNOWN_STATUS_CODE_PROXY_UNAUTHORIZED", "proxy-unauthorized" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_REQUEST_TIMEOUT), "SOUP_KNOWN_STATUS_CODE_REQUEST_TIMEOUT", "request-timeout" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_CONFLICT), "SOUP_KNOWN_STATUS_CODE_CONFLICT", "conflict" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_GONE), "SOUP_KNOWN_STATUS_CODE_GONE", "gone" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_LENGTH_REQUIRED), "SOUP_KNOWN_STATUS_CODE_LENGTH_REQUIRED", "length-required" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_PRECONDITION_FAILED), "SOUP_KNOWN_STATUS_CODE_PRECONDITION_FAILED", "precondition-failed" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_REQUEST_ENTITY_TOO_LARGE), "SOUP_KNOWN_STATUS_CODE_REQUEST_ENTITY_TOO_LARGE", "request-entity-too-large" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_REQUEST_URI_TOO_LONG), "SOUP_KNOWN_STATUS_CODE_REQUEST_URI_TOO_LONG", "request-uri-too-long" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_UNSUPPORTED_MEDIA_TYPE), "SOUP_KNOWN_STATUS_CODE_UNSUPPORTED_MEDIA_TYPE", "unsupported-media-type" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_REQUESTED_RANGE_NOT_SATISFIABLE), "SOUP_KNOWN_STATUS_CODE_REQUESTED_RANGE_NOT_SATISFIABLE", "requested-range-not-satisfiable" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_INVALID_RANGE), "SOUP_KNOWN_STATUS_CODE_INVALID_RANGE", "invalid-range" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_EXPECTATION_FAILED), "SOUP_KNOWN_STATUS_CODE_EXPECTATION_FAILED", "expectation-failed" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_UNPROCESSABLE_ENTITY), "SOUP_KNOWN_STATUS_CODE_UNPROCESSABLE_ENTITY", "unprocessable-entity" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_LOCKED), "SOUP_KNOWN_STATUS_CODE_LOCKED", "locked" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_FAILED_DEPENDENCY), "SOUP_KNOWN_STATUS_CODE_FAILED_DEPENDENCY", "failed-dependency" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_INTERNAL_SERVER_ERROR), "SOUP_KNOWN_STATUS_CODE_INTERNAL_SERVER_ERROR", "internal-server-error" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NOT_IMPLEMENTED), "SOUP_KNOWN_STATUS_CODE_NOT_IMPLEMENTED", "not-implemented" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_BAD_GATEWAY), "SOUP_KNOWN_STATUS_CODE_BAD_GATEWAY", "bad-gateway" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_SERVICE_UNAVAILABLE), "SOUP_KNOWN_STATUS_CODE_SERVICE_UNAVAILABLE", "service-unavailable" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_GATEWAY_TIMEOUT), "SOUP_KNOWN_STATUS_CODE_GATEWAY_TIMEOUT", "gateway-timeout" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_HTTP_VERSION_NOT_SUPPORTED), "SOUP_KNOWN_STATUS_CODE_HTTP_VERSION_NOT_SUPPORTED", "http-version-not-supported" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_INSUFFICIENT_STORAGE), "SOUP_KNOWN_STATUS_CODE_INSUFFICIENT_STORAGE", "insufficient-storage" }, + { C_ENUM(SOUP_KNOWN_STATUS_CODE_NOT_EXTENDED), "SOUP_KNOWN_STATUS_CODE_NOT_EXTENDED", "not-extended" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupKnownStatusCode", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-tld.h" */ +GType +soup_tld_error_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_TLD_ERROR_INVALID_HOSTNAME), "SOUP_TLD_ERROR_INVALID_HOSTNAME", "invalid-hostname" }, + { C_ENUM(SOUP_TLD_ERROR_IS_IP_ADDRESS), "SOUP_TLD_ERROR_IS_IP_ADDRESS", "is-ip-address" }, + { C_ENUM(SOUP_TLD_ERROR_NOT_ENOUGH_DOMAINS), "SOUP_TLD_ERROR_NOT_ENOUGH_DOMAINS", "not-enough-domains" }, + { C_ENUM(SOUP_TLD_ERROR_NO_BASE_DOMAIN), "SOUP_TLD_ERROR_NO_BASE_DOMAIN", "no-base-domain" }, + { C_ENUM(SOUP_TLD_ERROR_NO_PSL_DATA), "SOUP_TLD_ERROR_NO_PSL_DATA", "no-psl-data" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupTLDError", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-websocket.h" */ +GType +soup_websocket_error_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_WEBSOCKET_ERROR_FAILED), "SOUP_WEBSOCKET_ERROR_FAILED", "failed" }, + { C_ENUM(SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET), "SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET", "not-websocket" }, + { C_ENUM(SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE), "SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE", "bad-handshake" }, + { C_ENUM(SOUP_WEBSOCKET_ERROR_BAD_ORIGIN), "SOUP_WEBSOCKET_ERROR_BAD_ORIGIN", "bad-origin" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupWebsocketError", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_websocket_connection_type_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_WEBSOCKET_CONNECTION_UNKNOWN), "SOUP_WEBSOCKET_CONNECTION_UNKNOWN", "unknown" }, + { C_ENUM(SOUP_WEBSOCKET_CONNECTION_CLIENT), "SOUP_WEBSOCKET_CONNECTION_CLIENT", "client" }, + { C_ENUM(SOUP_WEBSOCKET_CONNECTION_SERVER), "SOUP_WEBSOCKET_CONNECTION_SERVER", "server" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupWebsocketConnectionType", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_websocket_data_type_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_WEBSOCKET_DATA_TEXT), "SOUP_WEBSOCKET_DATA_TEXT", "text" }, + { C_ENUM(SOUP_WEBSOCKET_DATA_BINARY), "SOUP_WEBSOCKET_DATA_BINARY", "binary" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupWebsocketDataType", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_websocket_close_code_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_WEBSOCKET_CLOSE_NORMAL), "SOUP_WEBSOCKET_CLOSE_NORMAL", "normal" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_GOING_AWAY), "SOUP_WEBSOCKET_CLOSE_GOING_AWAY", "going-away" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_PROTOCOL_ERROR), "SOUP_WEBSOCKET_CLOSE_PROTOCOL_ERROR", "protocol-error" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_UNSUPPORTED_DATA), "SOUP_WEBSOCKET_CLOSE_UNSUPPORTED_DATA", "unsupported-data" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_NO_STATUS), "SOUP_WEBSOCKET_CLOSE_NO_STATUS", "no-status" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_ABNORMAL), "SOUP_WEBSOCKET_CLOSE_ABNORMAL", "abnormal" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_BAD_DATA), "SOUP_WEBSOCKET_CLOSE_BAD_DATA", "bad-data" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_POLICY_VIOLATION), "SOUP_WEBSOCKET_CLOSE_POLICY_VIOLATION", "policy-violation" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_TOO_BIG), "SOUP_WEBSOCKET_CLOSE_TOO_BIG", "too-big" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_NO_EXTENSION), "SOUP_WEBSOCKET_CLOSE_NO_EXTENSION", "no-extension" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_SERVER_ERROR), "SOUP_WEBSOCKET_CLOSE_SERVER_ERROR", "server-error" }, + { C_ENUM(SOUP_WEBSOCKET_CLOSE_TLS_HANDSHAKE), "SOUP_WEBSOCKET_CLOSE_TLS_HANDSHAKE", "tls-handshake" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupWebsocketCloseCode", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_websocket_state_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_WEBSOCKET_STATE_OPEN), "SOUP_WEBSOCKET_STATE_OPEN", "open" }, + { C_ENUM(SOUP_WEBSOCKET_STATE_CLOSING), "SOUP_WEBSOCKET_STATE_CLOSING", "closing" }, + { C_ENUM(SOUP_WEBSOCKET_STATE_CLOSED), "SOUP_WEBSOCKET_STATE_CLOSED", "closed" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupWebsocketState", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +/* enumerations from "soup-xmlrpc.h" */ +GType +soup_xmlrpc_error_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_XMLRPC_ERROR_ARGUMENTS), "SOUP_XMLRPC_ERROR_ARGUMENTS", "arguments" }, + { C_ENUM(SOUP_XMLRPC_ERROR_RETVAL), "SOUP_XMLRPC_ERROR_RETVAL", "retval" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupXMLRPCError", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + +GType +soup_xmlrpc_fault_get_type (void) +{ + static gsize id = 0; + static const GEnumValue values[] = { + { C_ENUM(SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED), "SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED", "parse-error-not-well-formed" }, + { C_ENUM(SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING), "SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING", "parse-error-unsupported-encoding" }, + { C_ENUM(SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING), "SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING", "parse-error-invalid-character-for-encoding" }, + { C_ENUM(SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC), "SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC", "server-error-invalid-xml-rpc" }, + { C_ENUM(SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND), "SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND", "server-error-requested-method-not-found" }, + { C_ENUM(SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS), "SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS", "server-error-invalid-method-parameters" }, + { C_ENUM(SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR), "SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR", "server-error-internal-xml-rpc-error" }, + { C_ENUM(SOUP_XMLRPC_FAULT_APPLICATION_ERROR), "SOUP_XMLRPC_FAULT_APPLICATION_ERROR", "application-error" }, + { C_ENUM(SOUP_XMLRPC_FAULT_SYSTEM_ERROR), "SOUP_XMLRPC_FAULT_SYSTEM_ERROR", "system-error" }, + { C_ENUM(SOUP_XMLRPC_FAULT_TRANSPORT_ERROR), "SOUP_XMLRPC_FAULT_TRANSPORT_ERROR", "transport-error" }, + { 0, NULL, NULL } + }; + + if (g_once_init_enter (&id)) { + GType tmp = g_enum_register_static ("SoupXMLRPCFault", values); + g_once_init_leave (&id, tmp); + } + + return (GType) id; +} + + + +/* Generated data ends here */ + diff --git a/libsoup/soup-enum-types.h b/libsoup/soup-enum-types.h new file mode 100644 index 0000000000000000000000000000000000000000..2b633fde6791ac58c6a3d42dd1a1c6664621881e --- /dev/null +++ b/libsoup/soup-enum-types.h @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ +/* Generated data (by glib-mkenums) */ + +#ifndef __SOUP_ENUM_TYPES_H__ +#define __SOUP_ENUM_TYPES_H__ + +#include +#include +#define GLIB_MKENUMS_EXTERN _SOUP_EXTERN + +G_BEGIN_DECLS + +/* enumerations from "soup-address.h" */ +GLIB_MKENUMS_EXTERN GType soup_address_family_get_type (void); +#define SOUP_TYPE_ADDRESS_FAMILY (soup_address_family_get_type ()) + +/* enumerations from "soup-cache.h" */ +GLIB_MKENUMS_EXTERN GType soup_cacheability_get_type (void); +#define SOUP_TYPE_CACHEABILITY (soup_cacheability_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_cache_response_get_type (void); +#define SOUP_TYPE_CACHE_RESPONSE (soup_cache_response_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_cache_type_get_type (void); +#define SOUP_TYPE_CACHE_TYPE (soup_cache_type_get_type ()) + +/* enumerations from "soup-cookie.h" */ +GLIB_MKENUMS_EXTERN GType soup_same_site_policy_get_type (void); +#define SOUP_TYPE_SAME_SITE_POLICY (soup_same_site_policy_get_type ()) + +/* enumerations from "soup-cookie-jar.h" */ +GLIB_MKENUMS_EXTERN GType soup_cookie_jar_accept_policy_get_type (void); +#define SOUP_TYPE_COOKIE_JAR_ACCEPT_POLICY (soup_cookie_jar_accept_policy_get_type ()) + +/* enumerations from "soup-date.h" */ +GLIB_MKENUMS_EXTERN GType soup_date_format_get_type (void); +#define SOUP_TYPE_DATE_FORMAT (soup_date_format_get_type ()) + +/* enumerations from "soup-logger.h" */ +GLIB_MKENUMS_EXTERN GType soup_logger_log_level_get_type (void); +#define SOUP_TYPE_LOGGER_LOG_LEVEL (soup_logger_log_level_get_type ()) + +/* enumerations from "soup-message.h" */ +GLIB_MKENUMS_EXTERN GType soup_http_version_get_type (void); +#define SOUP_TYPE_HTTP_VERSION (soup_http_version_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_message_flags_get_type (void); +#define SOUP_TYPE_MESSAGE_FLAGS (soup_message_flags_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_message_priority_get_type (void); +#define SOUP_TYPE_MESSAGE_PRIORITY (soup_message_priority_get_type ()) + +/* enumerations from "soup-message-body.h" */ +GLIB_MKENUMS_EXTERN GType soup_memory_use_get_type (void); +#define SOUP_TYPE_MEMORY_USE (soup_memory_use_get_type ()) + +/* enumerations from "soup-message-headers.h" */ +GLIB_MKENUMS_EXTERN GType soup_message_headers_type_get_type (void); +#define SOUP_TYPE_MESSAGE_HEADERS_TYPE (soup_message_headers_type_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_encoding_get_type (void); +#define SOUP_TYPE_ENCODING (soup_encoding_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_expectation_get_type (void); +#define SOUP_TYPE_EXPECTATION (soup_expectation_get_type ()) + +/* enumerations from "soup-misc.h" */ +GLIB_MKENUMS_EXTERN GType soup_connection_state_get_type (void); +#define SOUP_TYPE_CONNECTION_STATE (soup_connection_state_get_type ()) + +/* enumerations from "soup-requester.h" */ +GLIB_MKENUMS_EXTERN GType soup_requester_error_get_type (void); +#define SOUP_TYPE_REQUESTER_ERROR (soup_requester_error_get_type ()) + +/* enumerations from "soup-server.h" */ +GLIB_MKENUMS_EXTERN GType soup_server_listen_options_get_type (void); +#define SOUP_TYPE_SERVER_LISTEN_OPTIONS (soup_server_listen_options_get_type ()) + +/* enumerations from "soup-session.h" */ +GLIB_MKENUMS_EXTERN GType soup_request_error_get_type (void); +#define SOUP_TYPE_REQUEST_ERROR (soup_request_error_get_type ()) + +/* enumerations from "soup-socket.h" */ +GLIB_MKENUMS_EXTERN GType soup_socket_io_status_get_type (void); +#define SOUP_TYPE_SOCKET_IO_STATUS (soup_socket_io_status_get_type ()) + +/* enumerations from "soup-status.h" */ +GLIB_MKENUMS_EXTERN GType soup_status_get_type (void); +#define SOUP_TYPE_STATUS (soup_status_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_known_status_code_get_type (void); +#define SOUP_TYPE_KNOWN_STATUS_CODE (soup_known_status_code_get_type ()) + +/* enumerations from "soup-tld.h" */ +GLIB_MKENUMS_EXTERN GType soup_tld_error_get_type (void); +#define SOUP_TYPE_TLD_ERROR (soup_tld_error_get_type ()) + +/* enumerations from "soup-websocket.h" */ +GLIB_MKENUMS_EXTERN GType soup_websocket_error_get_type (void); +#define SOUP_TYPE_WEBSOCKET_ERROR (soup_websocket_error_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_websocket_connection_type_get_type (void); +#define SOUP_TYPE_WEBSOCKET_CONNECTION_TYPE (soup_websocket_connection_type_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_websocket_data_type_get_type (void); +#define SOUP_TYPE_WEBSOCKET_DATA_TYPE (soup_websocket_data_type_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_websocket_close_code_get_type (void); +#define SOUP_TYPE_WEBSOCKET_CLOSE_CODE (soup_websocket_close_code_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_websocket_state_get_type (void); +#define SOUP_TYPE_WEBSOCKET_STATE (soup_websocket_state_get_type ()) + +/* enumerations from "soup-xmlrpc.h" */ +GLIB_MKENUMS_EXTERN GType soup_xmlrpc_error_get_type (void); +#define SOUP_TYPE_XMLRPC_ERROR (soup_xmlrpc_error_get_type ()) +GLIB_MKENUMS_EXTERN GType soup_xmlrpc_fault_get_type (void); +#define SOUP_TYPE_XMLRPC_FAULT (soup_xmlrpc_fault_get_type ()) +G_END_DECLS + +#endif /* __SOUP_ENUM_TYPES_H__ */ + +/* Generated data ends here */ + diff --git a/libsoup/soup-hsts-enforcer-db.c b/libsoup/soup-hsts-enforcer-db.c index bad688a0bffa2690ac3c090aa05606f88962edea..ea636bdd0f7a1f2b81833d0d3a446573c7f3874e 100644 --- a/libsoup/soup-hsts-enforcer-db.c +++ b/libsoup/soup-hsts-enforcer-db.c @@ -13,7 +13,12 @@ #include +// using the "sqlite3sym.h" in OHOS +#ifndef USE_SQLITE_SYMBOLS #include +#else +#include +#endif #include "soup-hsts-enforcer-db.h" #include "soup.h" diff --git a/libsoup/soup-version.h b/libsoup/soup-version.h new file mode 100644 index 0000000000000000000000000000000000000000..d58210bc2e6103f58d8a7f1405466409a2fcbd72 --- /dev/null +++ b/libsoup/soup-version.h @@ -0,0 +1,452 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. +*/ + +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ +/* + * soup-version.h: Version information + * + * Copyright (C) 2012 Igalia S.L. + */ + +#ifndef __SOUP_VERSION_H__ +#define __SOUP_VERSION_H__ + +#include + +G_BEGIN_DECLS + +#define SOUP_MAJOR_VERSION (2) +#define SOUP_MINOR_VERSION (71) +#define SOUP_MICRO_VERSION (0) + +#define SOUP_CHECK_VERSION(major, minor, micro) \ + (SOUP_MAJOR_VERSION > (major) || \ + (SOUP_MAJOR_VERSION == (major) && SOUP_MINOR_VERSION > (minor)) || \ + (SOUP_MAJOR_VERSION == (major) && SOUP_MINOR_VERSION == (minor) && \ + SOUP_MICRO_VERSION >= (micro))) + +#ifndef _SOUP_EXTERN +#define _SOUP_EXTERN extern +#endif + +/* We prefix variable declarations so they can + * properly get exported in Windows DLLs. + */ +#ifndef SOUP_VAR +# ifdef G_PLATFORM_WIN32 +# ifdef LIBSOUP_COMPILATION +# ifdef DLL_EXPORT +# define SOUP_VAR __declspec(dllexport) +# else /* !DLL_EXPORT */ +# define SOUP_VAR extern +# endif /* !DLL_EXPORT */ +# else /* !SOUP_COMPILATION */ +# define SOUP_VAR extern __declspec(dllimport) +# endif /* !LIBSOUP_COMPILATION */ +# else /* !G_PLATFORM_WIN32 */ +# define SOUP_VAR _SOUP_EXTERN +# endif /* !G_PLATFORM_WIN32 */ +#endif /* SOUP_VAR */ + +/* Deprecation / Availability macros */ + +#define SOUP_VERSION_2_24 (G_ENCODE_VERSION (2, 24)) +#define SOUP_VERSION_2_26 (G_ENCODE_VERSION (2, 26)) +#define SOUP_VERSION_2_28 (G_ENCODE_VERSION (2, 28)) +#define SOUP_VERSION_2_30 (G_ENCODE_VERSION (2, 30)) +#define SOUP_VERSION_2_32 (G_ENCODE_VERSION (2, 32)) +#define SOUP_VERSION_2_34 (G_ENCODE_VERSION (2, 34)) +#define SOUP_VERSION_2_36 (G_ENCODE_VERSION (2, 36)) +#define SOUP_VERSION_2_38 (G_ENCODE_VERSION (2, 38)) +#define SOUP_VERSION_2_40 (G_ENCODE_VERSION (2, 40)) +#define SOUP_VERSION_2_42 (G_ENCODE_VERSION (2, 42)) +#define SOUP_VERSION_2_44 (G_ENCODE_VERSION (2, 44)) +#define SOUP_VERSION_2_46 (G_ENCODE_VERSION (2, 46)) +#define SOUP_VERSION_2_48 (G_ENCODE_VERSION (2, 48)) +#define SOUP_VERSION_2_50 (G_ENCODE_VERSION (2, 50)) +#define SOUP_VERSION_2_52 (G_ENCODE_VERSION (2, 52)) +#define SOUP_VERSION_2_54 (G_ENCODE_VERSION (2, 54)) +#define SOUP_VERSION_2_56 (G_ENCODE_VERSION (2, 56)) +#define SOUP_VERSION_2_58 (G_ENCODE_VERSION (2, 58)) +#define SOUP_VERSION_2_62 (G_ENCODE_VERSION (2, 62)) +#define SOUP_VERSION_2_66 (G_ENCODE_VERSION (2, 66)) +#define SOUP_VERSION_2_68 (G_ENCODE_VERSION (2, 68)) +#define SOUP_VERSION_2_70 (G_ENCODE_VERSION (2, 70)) +#define SOUP_VERSION_2_72 (G_ENCODE_VERSION (2, 72)) + +/* evaluates to the current stable version; for development cycles, + * this means the next stable target + */ +#if (SOUP_MINOR_VERSION % 2) +#define SOUP_VERSION_CUR_STABLE (G_ENCODE_VERSION (SOUP_MAJOR_VERSION, SOUP_MINOR_VERSION + 1)) +#else +#define SOUP_VERSION_CUR_STABLE (G_ENCODE_VERSION (SOUP_MAJOR_VERSION, SOUP_MINOR_VERSION)) +#endif + +/* evaluates to the previous stable version */ +#if (SOUP_MINOR_VERSION % 2) +#define SOUP_VERSION_PREV_STABLE (G_ENCODE_VERSION (SOUP_MAJOR_VERSION, SOUP_MINOR_VERSION - 1)) +#else +#define SOUP_VERSION_PREV_STABLE (G_ENCODE_VERSION (SOUP_MAJOR_VERSION, SOUP_MINOR_VERSION - 2)) +#endif + +#ifndef SOUP_VERSION_MIN_REQUIRED +# define SOUP_VERSION_MIN_REQUIRED (SOUP_VERSION_CUR_STABLE) +#elif SOUP_VERSION_MIN_REQUIRED == 0 +# undef SOUP_VERSION_MIN_REQUIRED +# define SOUP_VERSION_MIN_REQUIRED (SOUP_VERSION_CUR_STABLE + 2) +#endif + +#if !defined (SOUP_VERSION_MAX_ALLOWED) || (SOUP_VERSION_MAX_ALLOWED == 0) +# undef SOUP_VERSION_MAX_ALLOWED +# define SOUP_VERSION_MAX_ALLOWED (SOUP_VERSION_CUR_STABLE) +#endif + +/* sanity checks */ +#if SOUP_VERSION_MIN_REQUIRED > SOUP_VERSION_CUR_STABLE +#error "SOUP_VERSION_MIN_REQUIRED must be <= SOUP_VERSION_CUR_STABLE" +#endif +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_MIN_REQUIRED +#error "SOUP_VERSION_MAX_ALLOWED must be >= SOUP_VERSION_MIN_REQUIRED" +#endif +#if SOUP_VERSION_MIN_REQUIRED < SOUP_VERSION_2_24 +#error "SOUP_VERSION_MIN_REQUIRED must be >= SOUP_VERSION_2_24" +#endif + +#define SOUP_AVAILABLE_IN_2_4 _SOUP_EXTERN + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_24 +# define SOUP_DEPRECATED_IN_2_24 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_24_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_24 +# define SOUP_DEPRECATED_IN_2_24_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_24 +# define SOUP_AVAILABLE_IN_2_24 G_UNAVAILABLE(2, 24) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_24 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_26 +# define SOUP_DEPRECATED_IN_2_26 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_26_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_26 +# define SOUP_DEPRECATED_IN_2_26_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_26 +# define SOUP_AVAILABLE_IN_2_26 G_UNAVAILABLE(2, 26) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_26 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_28 +# define SOUP_DEPRECATED_IN_2_28 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_28_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_28 +# define SOUP_DEPRECATED_IN_2_28_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_28 +# define SOUP_AVAILABLE_IN_2_28 G_UNAVAILABLE(2, 28) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_28 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_30 +# define SOUP_DEPRECATED_IN_2_30 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_30_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_30 +# define SOUP_DEPRECATED_IN_2_30_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_30 +# define SOUP_AVAILABLE_IN_2_30 G_UNAVAILABLE(2, 30) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_30 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_32 +# define SOUP_DEPRECATED_IN_2_32 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_32_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_32 +# define SOUP_DEPRECATED_IN_2_32_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_32 +# define SOUP_AVAILABLE_IN_2_32 G_UNAVAILABLE(2, 32) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_32 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_34 +# define SOUP_DEPRECATED_IN_2_34 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_34_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_34 +# define SOUP_DEPRECATED_IN_2_34_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_34 +# define SOUP_AVAILABLE_IN_2_34 G_UNAVAILABLE(2, 34) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_34 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_36 +# define SOUP_DEPRECATED_IN_2_36 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_36_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_36 +# define SOUP_DEPRECATED_IN_2_36_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_36 +# define SOUP_AVAILABLE_IN_2_36 G_UNAVAILABLE(2, 36) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_36 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_38 +# define SOUP_DEPRECATED_IN_2_38 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_38_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_38 +# define SOUP_DEPRECATED_IN_2_38_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_38 +# define SOUP_AVAILABLE_IN_2_38 G_UNAVAILABLE(2, 38) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_38 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_40 +# define SOUP_DEPRECATED_IN_2_40 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_40_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_40 +# define SOUP_DEPRECATED_IN_2_40_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_40 +# define SOUP_AVAILABLE_IN_2_40 G_UNAVAILABLE(2, 40) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_40 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_42 +# define SOUP_DEPRECATED_IN_2_42 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_42_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_42 +# define SOUP_DEPRECATED_IN_2_42_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_42 +# define SOUP_AVAILABLE_IN_2_42 G_UNAVAILABLE(2, 42) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_42 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_44 +# define SOUP_DEPRECATED_IN_2_44 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_44_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_44 +# define SOUP_DEPRECATED_IN_2_44_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_44 +# define SOUP_AVAILABLE_IN_2_44 G_UNAVAILABLE(2, 44) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_44 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_46 +# define SOUP_DEPRECATED_IN_2_46 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_46_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_46 +# define SOUP_DEPRECATED_IN_2_46_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_46 +# define SOUP_AVAILABLE_IN_2_46 G_UNAVAILABLE(2, 46) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_46 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_48 +# define SOUP_DEPRECATED_IN_2_48 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_48_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_48 +# define SOUP_DEPRECATED_IN_2_48_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_48 +# define SOUP_AVAILABLE_IN_2_48 G_UNAVAILABLE(2, 48) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_48 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_50 +# define SOUP_DEPRECATED_IN_2_50 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_50_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_50 +# define SOUP_DEPRECATED_IN_2_50_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_50 +# define SOUP_AVAILABLE_IN_2_50 G_UNAVAILABLE(2, 50) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_50 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_52 +# define SOUP_DEPRECATED_IN_2_52 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_52_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_52 +# define SOUP_DEPRECATED_IN_2_52_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_52 +# define SOUP_AVAILABLE_IN_2_52 G_UNAVAILABLE(2, 52) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_52 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_54 +# define SOUP_DEPRECATED_IN_2_54 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_54_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_54 +# define SOUP_DEPRECATED_IN_2_54_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_54 +# define SOUP_AVAILABLE_IN_2_54 G_UNAVAILABLE(2, 54) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_54 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_56 +# define SOUP_DEPRECATED_IN_2_56 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_56_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_56 +# define SOUP_DEPRECATED_IN_2_56_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_56 +# define SOUP_AVAILABLE_IN_2_56 G_UNAVAILABLE(2, 56) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_56 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_58 +# define SOUP_DEPRECATED_IN_2_58 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_58_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_58 +# define SOUP_DEPRECATED_IN_2_58_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_58 +# define SOUP_AVAILABLE_IN_2_58 G_UNAVAILABLE(2, 58) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_58 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_62 +# define SOUP_DEPRECATED_IN_2_62 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_62_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_62 +# define SOUP_DEPRECATED_IN_2_62_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_62 +# define SOUP_AVAILABLE_IN_2_62 G_UNAVAILABLE(2, 62) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_62 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_66 +# define SOUP_DEPRECATED_IN_2_66 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_66_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_66 +# define SOUP_DEPRECATED_IN_2_66_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_66 +# define SOUP_AVAILABLE_IN_2_66 G_UNAVAILABLE(2, 66) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_66 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_68 +# define SOUP_AVAILABLE_IN_2_68 G_UNAVAILABLE(2, 68) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_68 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MIN_REQUIRED >= SOUP_VERSION_2_70 +# define SOUP_DEPRECATED_IN_2_70 G_DEPRECATED +# define SOUP_DEPRECATED_IN_2_70_FOR(f) G_DEPRECATED_FOR(f) +#else +# define SOUP_DEPRECATED_IN_2_70 +# define SOUP_DEPRECATED_IN_2_70_FOR(f) +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_70 +# define SOUP_AVAILABLE_IN_2_70 G_UNAVAILABLE(2, 70) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_70 _SOUP_EXTERN +#endif + +#if SOUP_VERSION_MAX_ALLOWED < SOUP_VERSION_2_72 +# define SOUP_AVAILABLE_IN_2_72 G_UNAVAILABLE(2, 72) _SOUP_EXTERN +#else +# define SOUP_AVAILABLE_IN_2_72 _SOUP_EXTERN +#endif + +SOUP_AVAILABLE_IN_2_42 +guint soup_get_major_version (void); + +SOUP_AVAILABLE_IN_2_42 +guint soup_get_minor_version (void); + +SOUP_AVAILABLE_IN_2_42 +guint soup_get_micro_version (void); + +SOUP_AVAILABLE_IN_2_42 +gboolean soup_check_version (guint major, + guint minor, + guint micro); + +G_END_DECLS + +#endif /* __SOUP_VERSION_H__ */ \ No newline at end of file