gl_linkedhash_list.c:gl_linked_nx_create_empty: 45| 2|{ 46| 2| struct gl_list_impl *list = 47| 2| (struct gl_list_impl *) malloc (sizeof (struct gl_list_impl)); 48| | 49| 2| if (list == NULL) ------------------ | Branch (49:7): [True: 0, False: 2] ------------------ 50| 0| return NULL; 51| | 52| 2| list->base.vtable = implementation; 53| 2| list->base.equals_fn = equals_fn; 54| 2| list->base.hashcode_fn = hashcode_fn; 55| 2| list->base.dispose_fn = dispose_fn; 56| 2| list->base.allow_duplicates = allow_duplicates; 57| 2|#if WITH_HASHTABLE 58| 2| list->table_size = 11; 59| 2| list->table = 60| 2| (gl_hash_entry_t *) calloc (list->table_size, sizeof (gl_hash_entry_t)); 61| 2| if (list->table == NULL) ------------------ | Branch (61:7): [True: 0, False: 2] ------------------ 62| 0| goto fail; 63| 2|#endif 64| 2| list->root.next = &list->root; 65| 2| list->root.prev = &list->root; 66| 2| list->count = 0; 67| | 68| 2| return list; 69| | 70| 0|#if WITH_HASHTABLE 71| 0| fail: 72| 0| free (list); 73| 0| return NULL; 74| 2|#endif 75| 2|} gl_list_nx_create_empty: 607| 2|{ 608| 2| return implementation->nx_create_empty (implementation, equals_fn, 609| 2| hashcode_fn, dispose_fn, 610| 2| allow_duplicates); 611| 2|} _gnutls_register_accel_crypto: 33| 2|{ 34| 2|#if defined(ASM_X86) 35| 2| register_x86_crypto(); 36| 2|#endif 37| | 38| |#if defined(ASM_AARCH64) 39| | register_aarch64_crypto(); 40| |#endif 41| | 42| 2| return; 43| 2|} _gnutls_afalg_init: 864| 2|{ 865| 2| return 0; 866| 2|} _gnutls_cryptodev_init: 505| 2|{ 506| 2| return 0; 507| 2|} register_x86_crypto: 1235| 2|{ 1236| 2| unsigned capabilities = 0; 1237| 2| char *p; 1238| 2| p = secure_getenv("GNUTLS_CPUID_OVERRIDE"); 1239| 2| if (p) { ------------------ | Branch (1239:6): [True: 0, False: 2] ------------------ 1240| 0| capabilities = strtol(p, NULL, 0); 1241| 0| } 1242| | 1243| 2| register_x86_intel_crypto(capabilities); 1244| 2|#ifdef ENABLE_PADLOCK 1245| 2| register_x86_padlock_crypto(capabilities); 1246| 2|#endif 1247| 2|} x86-common.c:register_x86_intel_crypto: 900| 2|{ 901| 2| int ret; 902| 2| enum x86_cpu_vendor vendor; 903| | 904| 2| memset(GNUTLS_x86_cpuid_s, 0, sizeof(GNUTLS_x86_cpuid_s)); 905| | 906| 2| vendor = check_x86_cpu_vendor(); 907| 2| if (vendor == X86_CPU_VENDOR_OTHER) { ------------------ | Branch (907:6): [True: 0, False: 2] ------------------ 908| 0| return; 909| 0| } 910| | 911| 2| if (capabilities == 0) { ------------------ | Branch (911:6): [True: 2, False: 0] ------------------ 912| 2| if (!read_cpuid_vals(GNUTLS_x86_cpuid_s)) ------------------ | Branch (912:7): [True: 0, False: 2] ------------------ 913| 0| return; 914| 2| if (!check_4th_gen_intel_features(GNUTLS_x86_cpuid_s[1])) { ------------------ | Branch (914:7): [True: 0, False: 2] ------------------ 915| 0| GNUTLS_x86_cpuid_s[1] &= ~bit_AVX; 916| | 917| | /* Clear AVX2 bits as well, according to what 918| | * OpenSSL does. Should we clear 919| | * bit_AVX512DQ, bit_AVX512PF, bit_AVX512ER, 920| | * and bit_AVX512CD? */ 921| 0| GNUTLS_x86_cpuid_s[2] &= ~(bit_AVX2 | 922| 0| bit_AVX512F | 923| 0| bit_AVX512IFMA | 924| 0| bit_AVX512BW | bit_AVX512BW); 925| 0| } 926| 2| } else { 927| 0| capabilities_to_intel_cpuid(capabilities); 928| 0| } 929| | 930| | /* CRYPTOGAMS uses the (1 << 30) bit as an indicator of Intel CPUs */ 931| 2| if (vendor == X86_CPU_VENDOR_INTEL) { ------------------ | Branch (931:6): [True: 0, False: 2] ------------------ 932| 0| GNUTLS_x86_cpuid_s[0] |= 1 << 30; 933| 2| } else { 934| 2| GNUTLS_x86_cpuid_s[0] &= ~(1 << 30); 935| 2| } 936| | 937| 2| if (check_ssse3()) { ------------------ | Branch (937:6): [True: 2, False: 0] ------------------ 938| 2| _gnutls_debug_log("Intel SSSE3 was detected\n"); ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 939| | 940| 2| ret = 941| 2| gnutls_crypto_single_cipher_register 942| 2| (GNUTLS_CIPHER_AES_128_GCM, 90, 943| 2| &_gnutls_aes_gcm_x86_ssse3, 0); 944| 2| if (ret < 0) { ------------------ | Branch (944:7): [True: 0, False: 2] ------------------ 945| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 946| 0| } 947| | 948| 2| ret = 949| 2| gnutls_crypto_single_cipher_register 950| 2| (GNUTLS_CIPHER_AES_192_GCM, 90, 951| 2| &_gnutls_aes_gcm_x86_ssse3, 0); 952| 2| if (ret < 0) { ------------------ | Branch (952:7): [True: 0, False: 2] ------------------ 953| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 954| 0| } 955| | 956| 2| ret = 957| 2| gnutls_crypto_single_cipher_register 958| 2| (GNUTLS_CIPHER_AES_256_GCM, 90, 959| 2| &_gnutls_aes_gcm_x86_ssse3, 0); 960| 2| if (ret < 0) { ------------------ | Branch (960:7): [True: 0, False: 2] ------------------ 961| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 962| 0| } 963| | 964| 2| ret = 965| 2| gnutls_crypto_single_cipher_register 966| 2| (GNUTLS_CIPHER_AES_128_CBC, 90, &_gnutls_aes_ssse3, 0); 967| 2| if (ret < 0) { ------------------ | Branch (967:7): [True: 0, False: 2] ------------------ 968| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 969| 0| } 970| | 971| 2| ret = 972| 2| gnutls_crypto_single_cipher_register 973| 2| (GNUTLS_CIPHER_AES_192_CBC, 90, &_gnutls_aes_ssse3, 0); 974| 2| if (ret < 0) { ------------------ | Branch (974:7): [True: 0, False: 2] ------------------ 975| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 976| 0| } 977| | 978| 2| ret = 979| 2| gnutls_crypto_single_cipher_register 980| 2| (GNUTLS_CIPHER_AES_256_CBC, 90, &_gnutls_aes_ssse3, 0); 981| 2| if (ret < 0) { ------------------ | Branch (981:7): [True: 0, False: 2] ------------------ 982| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 983| 0| } 984| 2| } 985| | 986| 2| if (check_sha() || check_ssse3()) { ------------------ | Branch (986:6): [True: 2, False: 0] | Branch (986:21): [True: 0, False: 0] ------------------ 987| 2| if (check_sha()) ------------------ | Branch (987:7): [True: 2, False: 0] ------------------ 988| 2| _gnutls_debug_log("Intel SHA was detected\n"); ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 989| | 990| 2| ret = 991| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA1, 992| 2| 80, 993| 2| &_gnutls_sha_x86_ssse3, 994| 2| 0); 995| 2| if (ret < 0) { ------------------ | Branch (995:7): [True: 0, False: 2] ------------------ 996| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 997| 0| } 998| | 999| 2| ret = 1000| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA224, 1001| 2| 80, 1002| 2| &_gnutls_sha_x86_ssse3, 1003| 2| 0); 1004| 2| if (ret < 0) { ------------------ | Branch (1004:7): [True: 0, False: 2] ------------------ 1005| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1006| 0| } 1007| | 1008| 2| ret = 1009| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA256, 1010| 2| 80, 1011| 2| &_gnutls_sha_x86_ssse3, 1012| 2| 0); 1013| 2| if (ret < 0) { ------------------ | Branch (1013:7): [True: 0, False: 2] ------------------ 1014| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1015| 0| } 1016| | 1017| 2| ret = 1018| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA1, 1019| 2| 80, 1020| 2| &_gnutls_hmac_sha_x86_ssse3, 1021| 2| 0); 1022| 2| if (ret < 0) ------------------ | Branch (1022:7): [True: 0, False: 2] ------------------ 1023| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1024| | 1025| 2| ret = 1026| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA224, 1027| 2| 80, 1028| 2| &_gnutls_hmac_sha_x86_ssse3, 1029| 2| 0); 1030| 2| if (ret < 0) ------------------ | Branch (1030:7): [True: 0, False: 2] ------------------ 1031| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1032| | 1033| 2| ret = 1034| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA256, 1035| 2| 80, 1036| 2| &_gnutls_hmac_sha_x86_ssse3, 1037| 2| 0); 1038| 2| if (ret < 0) ------------------ | Branch (1038:7): [True: 0, False: 2] ------------------ 1039| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1040| | 1041| 2| ret = 1042| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA384, 1043| 2| 80, 1044| 2| &_gnutls_sha_x86_ssse3, 1045| 2| 0); 1046| 2| if (ret < 0) ------------------ | Branch (1046:7): [True: 0, False: 2] ------------------ 1047| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1048| | 1049| 2| ret = 1050| 2| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA512, 1051| 2| 80, 1052| 2| &_gnutls_sha_x86_ssse3, 1053| 2| 0); 1054| 2| if (ret < 0) ------------------ | Branch (1054:7): [True: 0, False: 2] ------------------ 1055| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1056| 2| ret = 1057| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA384, 1058| 2| 80, 1059| 2| &_gnutls_hmac_sha_x86_ssse3, 1060| 2| 0); 1061| 2| if (ret < 0) ------------------ | Branch (1061:7): [True: 0, False: 2] ------------------ 1062| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1063| | 1064| 2| ret = 1065| 2| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA512, 1066| 2| 80, 1067| 2| &_gnutls_hmac_sha_x86_ssse3, 1068| 2| 0); 1069| 2| if (ret < 0) ------------------ | Branch (1069:7): [True: 0, False: 2] ------------------ 1070| 2| gnutls_assert(); ------------------ | | 33| 2|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1071| 2| } 1072| | 1073| 2| if (check_optimized_aes()) { ------------------ | Branch (1073:6): [True: 2, False: 0] ------------------ 1074| 2| _gnutls_debug_log("Intel AES accelerator was detected\n"); ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1075| 2| ret = 1076| 2| gnutls_crypto_single_cipher_register 1077| 2| (GNUTLS_CIPHER_AES_128_CBC, 80, &_gnutls_aesni_x86, 0); 1078| 2| if (ret < 0) { ------------------ | Branch (1078:7): [True: 0, False: 2] ------------------ 1079| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1080| 0| } 1081| | 1082| 2| ret = 1083| 2| gnutls_crypto_single_cipher_register 1084| 2| (GNUTLS_CIPHER_AES_192_CBC, 80, &_gnutls_aesni_x86, 0); 1085| 2| if (ret < 0) { ------------------ | Branch (1085:7): [True: 0, False: 2] ------------------ 1086| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1087| 0| } 1088| | 1089| 2| ret = 1090| 2| gnutls_crypto_single_cipher_register 1091| 2| (GNUTLS_CIPHER_AES_256_CBC, 80, &_gnutls_aesni_x86, 0); 1092| 2| if (ret < 0) { ------------------ | Branch (1092:7): [True: 0, False: 2] ------------------ 1093| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1094| 0| } 1095| | 1096| 2| ret = 1097| 2| gnutls_crypto_single_cipher_register 1098| 2| (GNUTLS_CIPHER_AES_128_CCM, 80, 1099| 2| &_gnutls_aes_ccm_x86_aesni, 0); 1100| 2| if (ret < 0) { ------------------ | Branch (1100:7): [True: 0, False: 2] ------------------ 1101| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1102| 0| } 1103| | 1104| 2| ret = 1105| 2| gnutls_crypto_single_cipher_register 1106| 2| (GNUTLS_CIPHER_AES_256_CCM, 80, 1107| 2| &_gnutls_aes_ccm_x86_aesni, 0); 1108| 2| if (ret < 0) { ------------------ | Branch (1108:7): [True: 0, False: 2] ------------------ 1109| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1110| 0| } 1111| | 1112| 2| ret = 1113| 2| gnutls_crypto_single_cipher_register 1114| 2| (GNUTLS_CIPHER_AES_128_CCM_8, 80, 1115| 2| &_gnutls_aes_ccm_x86_aesni, 0); 1116| 2| if (ret < 0) { ------------------ | Branch (1116:7): [True: 0, False: 2] ------------------ 1117| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1118| 0| } 1119| | 1120| 2| ret = 1121| 2| gnutls_crypto_single_cipher_register 1122| 2| (GNUTLS_CIPHER_AES_256_CCM_8, 80, 1123| 2| &_gnutls_aes_ccm_x86_aesni, 0); 1124| 2| if (ret < 0) { ------------------ | Branch (1124:7): [True: 0, False: 2] ------------------ 1125| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1126| 0| } 1127| | 1128| 2| ret = 1129| 2| gnutls_crypto_single_cipher_register 1130| 2| (GNUTLS_CIPHER_AES_128_XTS, 80, 1131| 2| &_gnutls_aes_xts_x86_aesni, 0); 1132| 2| if (ret < 0) { ------------------ | Branch (1132:7): [True: 0, False: 2] ------------------ 1133| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1134| 0| } 1135| | 1136| 2| ret = 1137| 2| gnutls_crypto_single_cipher_register 1138| 2| (GNUTLS_CIPHER_AES_256_XTS, 80, 1139| 2| &_gnutls_aes_xts_x86_aesni, 0); 1140| 2| if (ret < 0) { ------------------ | Branch (1140:7): [True: 0, False: 2] ------------------ 1141| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1142| 0| } 1143| | 1144| 2|#ifdef ASM_X86_64 1145| 2| if (check_pclmul()) { ------------------ | Branch (1145:7): [True: 2, False: 0] ------------------ 1146| | /* register GCM ciphers */ 1147| 2| if (check_avx_movbe()) { ------------------ | Branch (1147:8): [True: 2, False: 0] ------------------ 1148| 2| _gnutls_debug_log ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1149| 2| ("Intel GCM accelerator (AVX) was detected\n"); 1150| 2| ret = 1151| 2| gnutls_crypto_single_cipher_register 1152| 2| (GNUTLS_CIPHER_AES_128_GCM, 80, 1153| 2| &_gnutls_aes_gcm_pclmul_avx, 0); 1154| 2| if (ret < 0) { ------------------ | Branch (1154:9): [True: 0, False: 2] ------------------ 1155| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1156| 0| } 1157| | 1158| 2| ret = 1159| 2| gnutls_crypto_single_cipher_register 1160| 2| (GNUTLS_CIPHER_AES_192_GCM, 80, 1161| 2| &_gnutls_aes_gcm_pclmul_avx, 0); 1162| 2| if (ret < 0) { ------------------ | Branch (1162:9): [True: 0, False: 2] ------------------ 1163| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1164| 0| } 1165| | 1166| 2| ret = 1167| 2| gnutls_crypto_single_cipher_register 1168| 2| (GNUTLS_CIPHER_AES_256_GCM, 80, 1169| 2| &_gnutls_aes_gcm_pclmul_avx, 0); 1170| 2| if (ret < 0) { ------------------ | Branch (1170:9): [True: 0, False: 2] ------------------ 1171| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1172| 0| } 1173| 2| } else { 1174| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 1175| 0| ("Intel GCM accelerator was detected\n"); 1176| 0| ret = 1177| 0| gnutls_crypto_single_cipher_register 1178| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 1179| 0| &_gnutls_aes_gcm_pclmul, 0); 1180| 0| if (ret < 0) { ------------------ | Branch (1180:9): [True: 0, False: 0] ------------------ 1181| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1182| 0| } 1183| | 1184| 0| ret = 1185| 0| gnutls_crypto_single_cipher_register 1186| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 1187| 0| &_gnutls_aes_gcm_pclmul, 0); 1188| 0| if (ret < 0) { ------------------ | Branch (1188:9): [True: 0, False: 0] ------------------ 1189| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1190| 0| } 1191| | 1192| 0| ret = 1193| 0| gnutls_crypto_single_cipher_register 1194| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 1195| 0| &_gnutls_aes_gcm_pclmul, 0); 1196| 0| if (ret < 0) { ------------------ | Branch (1196:9): [True: 0, False: 0] ------------------ 1197| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1198| 0| } 1199| 0| } 1200| 2| } else 1201| 0|#endif 1202| 0| { 1203| 0| ret = 1204| 0| gnutls_crypto_single_cipher_register 1205| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 1206| 0| &_gnutls_aes_gcm_x86_aesni, 0); 1207| 0| if (ret < 0) { ------------------ | Branch (1207:8): [True: 0, False: 0] ------------------ 1208| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1209| 0| } 1210| | 1211| 0| ret = 1212| 0| gnutls_crypto_single_cipher_register 1213| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 1214| 0| &_gnutls_aes_gcm_x86_aesni, 0); 1215| 0| if (ret < 0) { ------------------ | Branch (1215:8): [True: 0, False: 0] ------------------ 1216| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1217| 0| } 1218| | 1219| 0| ret = 1220| 0| gnutls_crypto_single_cipher_register 1221| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 1222| 0| &_gnutls_aes_gcm_x86_aesni, 0); 1223| 0| if (ret < 0) { ------------------ | Branch (1223:8): [True: 0, False: 0] ------------------ 1224| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1225| 0| } 1226| 0| } 1227| 2| } else { 1228| 0| _gnutls_priority_update_non_aesni(); 1229| 0| } 1230| | 1231| 2| return; 1232| 2|} x86-common.c:check_x86_cpu_vendor: 878| 2|{ 879| 2| unsigned int a, b, c, d; 880| | 881| 2| if (!__get_cpuid(0, &a, &b, &c, &d)) { ------------------ | Branch (881:6): [True: 0, False: 2] ------------------ 882| 0| return X86_CPU_VENDOR_OTHER; 883| 0| } 884| | 885| 2| if (memcmp(&b, "Genu", 4) == 0 && ------------------ | Branch (885:6): [True: 0, False: 2] ------------------ 886| 2| memcmp(&d, "ineI", 4) == 0 && memcmp(&c, "ntel", 4) == 0) { ------------------ | Branch (886:6): [True: 0, False: 0] | Branch (886:36): [True: 0, False: 0] ------------------ 887| 0| return X86_CPU_VENDOR_INTEL; 888| 0| } 889| | 890| 2| if (memcmp(&b, "Auth", 4) == 0 && ------------------ | Branch (890:6): [True: 2, False: 0] ------------------ 891| 2| memcmp(&d, "enti", 4) == 0 && memcmp(&c, "cAMD", 4) == 0) { ------------------ | Branch (891:6): [True: 2, False: 0] | Branch (891:36): [True: 2, False: 0] ------------------ 892| 2| return X86_CPU_VENDOR_AMD; 893| 2| } 894| | 895| 0| return X86_CPU_VENDOR_OTHER; 896| 2|} x86-common.c:read_cpuid_vals: 145| 2|{ 146| 2| unsigned t1, t2, t3; 147| 2| vals[0] = vals[1] = vals[2] = vals[3] = 0; 148| | 149| 2| if (!__get_cpuid(1, &t1, &t2, &vals[1], &vals[0])) ------------------ | Branch (149:6): [True: 0, False: 2] ------------------ 150| 0| return 0; 151| | /* suppress AVX512; it works conditionally on certain CPUs on the original code */ 152| 2| vals[1] &= 0xfffff7ff; 153| | 154| 2| get_cpuid_level7(&t1, &vals[2], &t2, &t3); ------------------ | | 141| 2|# define get_cpuid_level7(a,b,c,d) __get_cpuid_count(7, 0, a, b, c, d) ------------------ 155| | 156| 2| return 1; 157| 2|} x86-common.c:check_4th_gen_intel_features: 164| 2|{ 165| 2| uint32_t xcr0; 166| | 167| 2| if ((ecx & bit_OSXSAVE) != bit_OSXSAVE) ------------------ | Branch (167:6): [True: 0, False: 2] ------------------ 168| 0| return 0; 169| | 170| |#if defined(_MSC_VER) && !defined(__clang__) 171| | xcr0 = _xgetbv(0); 172| |#else 173| 2| __asm__("xgetbv": "=a"(xcr0): "c"(0):"%edx"); 174| 2|#endif 175| | /* Check if xmm and ymm state are enabled in XCR0. */ 176| 2| return (xcr0 & 6) == 6; 177| 2|} x86-common.c:check_ssse3: 243| 2|{ 244| 2| return (GNUTLS_x86_cpuid_s[1] & bit_SSSE3); 245| 2|} x86-common.c:check_sha: 248| 4|{ 249| 4| return (GNUTLS_x86_cpuid_s[2] & bit_SHA); 250| 4|} x86-common.c:check_optimized_aes: 238| 2|{ 239| 2| return (GNUTLS_x86_cpuid_s[1] & bit_AES); 240| 2|} x86-common.c:check_pclmul: 260| 2|{ 261| 2| return (GNUTLS_x86_cpuid_s[1] & bit_PCLMUL); 262| 2|} x86-common.c:check_avx_movbe: 254| 2|{ 255| 2| return (GNUTLS_x86_cpuid_s[1] & (bit_AVX | bit_MOVBE)) == 256| 2| (bit_AVX | bit_MOVBE); 257| 2|} x86-common.c:register_x86_padlock_crypto: 384| 2|{ 385| 2| int ret, phe; 386| 2| unsigned edx; 387| | 388| 2| if (check_zhaoxin() == 0) ------------------ | Branch (388:6): [True: 2, False: 0] ------------------ 389| 2| return; 390| | 391| 0| memset(GNUTLS_x86_cpuid_s, 0, sizeof(GNUTLS_x86_cpuid_s)); 392| | 393| 0| if (capabilities == 0) { ------------------ | Branch (393:6): [True: 0, False: 0] ------------------ 394| 0| if (!read_cpuid_vals(GNUTLS_x86_cpuid_s)) ------------------ | Branch (394:7): [True: 0, False: 0] ------------------ 395| 0| return; 396| 0| edx = padlock_capability(); 397| 0| } else { 398| 0| capabilities_to_intel_cpuid(capabilities); 399| 0| edx = capabilities_to_zhaoxin_edx(capabilities); 400| 0| } 401| | 402| 0| if (check_ssse3()) { ------------------ | Branch (402:6): [True: 0, False: 0] ------------------ 403| 0| _gnutls_debug_log("Zhaoxin SSSE3 was detected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 404| | 405| 0| ret = 406| 0| gnutls_crypto_single_cipher_register 407| 0| (GNUTLS_CIPHER_AES_128_GCM, 90, 408| 0| &_gnutls_aes_gcm_x86_ssse3, 0); 409| 0| if (ret < 0) { ------------------ | Branch (409:7): [True: 0, False: 0] ------------------ 410| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 411| 0| } 412| | 413| 0| ret = 414| 0| gnutls_crypto_single_cipher_register 415| 0| (GNUTLS_CIPHER_AES_192_GCM, 90, 416| 0| &_gnutls_aes_gcm_x86_ssse3, 0); 417| 0| if (ret < 0) { ------------------ | Branch (417:7): [True: 0, False: 0] ------------------ 418| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 419| 0| } 420| | 421| 0| ret = 422| 0| gnutls_crypto_single_cipher_register 423| 0| (GNUTLS_CIPHER_AES_256_GCM, 90, 424| 0| &_gnutls_aes_gcm_x86_ssse3, 0); 425| 0| if (ret < 0) { ------------------ | Branch (425:7): [True: 0, False: 0] ------------------ 426| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 427| 0| } 428| | 429| 0| ret = 430| 0| gnutls_crypto_single_cipher_register 431| 0| (GNUTLS_CIPHER_AES_128_CBC, 90, &_gnutls_aes_ssse3, 0); 432| 0| if (ret < 0) { ------------------ | Branch (432:7): [True: 0, False: 0] ------------------ 433| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 434| 0| } 435| | 436| 0| ret = 437| 0| gnutls_crypto_single_cipher_register 438| 0| (GNUTLS_CIPHER_AES_192_CBC, 90, &_gnutls_aes_ssse3, 0); 439| 0| if (ret < 0) { ------------------ | Branch (439:7): [True: 0, False: 0] ------------------ 440| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 441| 0| } 442| | 443| 0| ret = 444| 0| gnutls_crypto_single_cipher_register 445| 0| (GNUTLS_CIPHER_AES_256_CBC, 90, &_gnutls_aes_ssse3, 0); 446| 0| if (ret < 0) { ------------------ | Branch (446:7): [True: 0, False: 0] ------------------ 447| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 448| 0| } 449| 0| } 450| | 451| 0| if (check_sha() || check_ssse3()) { ------------------ | Branch (451:6): [True: 0, False: 0] | Branch (451:21): [True: 0, False: 0] ------------------ 452| 0| if (check_sha()) ------------------ | Branch (452:7): [True: 0, False: 0] ------------------ 453| 0| _gnutls_debug_log("Zhaoxin SHA was detected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 454| | 455| 0| ret = 456| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA1, 457| 0| 80, 458| 0| &_gnutls_sha_x86_ssse3, 459| 0| 0); 460| 0| if (ret < 0) { ------------------ | Branch (460:7): [True: 0, False: 0] ------------------ 461| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 462| 0| } 463| | 464| 0| ret = 465| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA224, 466| 0| 80, 467| 0| &_gnutls_sha_x86_ssse3, 468| 0| 0); 469| 0| if (ret < 0) { ------------------ | Branch (469:7): [True: 0, False: 0] ------------------ 470| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 471| 0| } 472| | 473| 0| ret = 474| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA256, 475| 0| 80, 476| 0| &_gnutls_sha_x86_ssse3, 477| 0| 0); 478| 0| if (ret < 0) { ------------------ | Branch (478:7): [True: 0, False: 0] ------------------ 479| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 480| 0| } 481| | 482| 0| ret = 483| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA1, 484| 0| 80, 485| 0| &_gnutls_hmac_sha_x86_ssse3, 486| 0| 0); 487| 0| if (ret < 0) ------------------ | Branch (487:7): [True: 0, False: 0] ------------------ 488| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 489| | 490| 0| ret = 491| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA224, 492| 0| 80, 493| 0| &_gnutls_hmac_sha_x86_ssse3, 494| 0| 0); 495| 0| if (ret < 0) ------------------ | Branch (495:7): [True: 0, False: 0] ------------------ 496| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 497| | 498| 0| ret = 499| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA256, 500| 0| 80, 501| 0| &_gnutls_hmac_sha_x86_ssse3, 502| 0| 0); 503| 0| if (ret < 0) ------------------ | Branch (503:7): [True: 0, False: 0] ------------------ 504| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 505| | 506| 0| ret = 507| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA384, 508| 0| 80, 509| 0| &_gnutls_sha_x86_ssse3, 510| 0| 0); 511| 0| if (ret < 0) ------------------ | Branch (511:7): [True: 0, False: 0] ------------------ 512| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 513| | 514| 0| ret = 515| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA512, 516| 0| 80, 517| 0| &_gnutls_sha_x86_ssse3, 518| 0| 0); 519| 0| if (ret < 0) ------------------ | Branch (519:7): [True: 0, False: 0] ------------------ 520| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 521| 0| ret = 522| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA384, 523| 0| 80, 524| 0| &_gnutls_hmac_sha_x86_ssse3, 525| 0| 0); 526| 0| if (ret < 0) ------------------ | Branch (526:7): [True: 0, False: 0] ------------------ 527| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 528| | 529| 0| ret = 530| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA512, 531| 0| 80, 532| 0| &_gnutls_hmac_sha_x86_ssse3, 533| 0| 0); 534| 0| if (ret < 0) ------------------ | Branch (534:7): [True: 0, False: 0] ------------------ 535| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 536| 0| } 537| | 538| 0| if (check_optimized_aes()) { ------------------ | Branch (538:6): [True: 0, False: 0] ------------------ 539| 0| _gnutls_debug_log("Zhaoxin AES accelerator was detected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 540| 0| ret = 541| 0| gnutls_crypto_single_cipher_register 542| 0| (GNUTLS_CIPHER_AES_128_CBC, 80, &_gnutls_aesni_x86, 0); 543| 0| if (ret < 0) { ------------------ | Branch (543:7): [True: 0, False: 0] ------------------ 544| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 545| 0| } 546| | 547| 0| ret = 548| 0| gnutls_crypto_single_cipher_register 549| 0| (GNUTLS_CIPHER_AES_192_CBC, 80, &_gnutls_aesni_x86, 0); 550| 0| if (ret < 0) { ------------------ | Branch (550:7): [True: 0, False: 0] ------------------ 551| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 552| 0| } 553| | 554| 0| ret = 555| 0| gnutls_crypto_single_cipher_register 556| 0| (GNUTLS_CIPHER_AES_256_CBC, 80, &_gnutls_aesni_x86, 0); 557| 0| if (ret < 0) { ------------------ | Branch (557:7): [True: 0, False: 0] ------------------ 558| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 559| 0| } 560| | 561| 0| ret = 562| 0| gnutls_crypto_single_cipher_register 563| 0| (GNUTLS_CIPHER_AES_128_CCM, 80, 564| 0| &_gnutls_aes_ccm_x86_aesni, 0); 565| 0| if (ret < 0) { ------------------ | Branch (565:7): [True: 0, False: 0] ------------------ 566| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 567| 0| } 568| | 569| 0| ret = 570| 0| gnutls_crypto_single_cipher_register 571| 0| (GNUTLS_CIPHER_AES_256_CCM, 80, 572| 0| &_gnutls_aes_ccm_x86_aesni, 0); 573| 0| if (ret < 0) { ------------------ | Branch (573:7): [True: 0, False: 0] ------------------ 574| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 575| 0| } 576| | 577| 0| ret = 578| 0| gnutls_crypto_single_cipher_register 579| 0| (GNUTLS_CIPHER_AES_128_CCM_8, 80, 580| 0| &_gnutls_aes_ccm_x86_aesni, 0); 581| 0| if (ret < 0) { ------------------ | Branch (581:7): [True: 0, False: 0] ------------------ 582| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 583| 0| } 584| | 585| 0| ret = 586| 0| gnutls_crypto_single_cipher_register 587| 0| (GNUTLS_CIPHER_AES_256_CCM_8, 80, 588| 0| &_gnutls_aes_ccm_x86_aesni, 0); 589| 0| if (ret < 0) { ------------------ | Branch (589:7): [True: 0, False: 0] ------------------ 590| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 591| 0| } 592| | 593| 0| ret = 594| 0| gnutls_crypto_single_cipher_register 595| 0| (GNUTLS_CIPHER_AES_128_XTS, 80, 596| 0| &_gnutls_aes_xts_x86_aesni, 0); 597| 0| if (ret < 0) { ------------------ | Branch (597:7): [True: 0, False: 0] ------------------ 598| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 599| 0| } 600| | 601| 0| ret = 602| 0| gnutls_crypto_single_cipher_register 603| 0| (GNUTLS_CIPHER_AES_256_XTS, 80, 604| 0| &_gnutls_aes_xts_x86_aesni, 0); 605| 0| if (ret < 0) { ------------------ | Branch (605:7): [True: 0, False: 0] ------------------ 606| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 607| 0| } 608| | 609| 0|# ifdef ASM_X86_64 610| 0| if (check_pclmul()) { ------------------ | Branch (610:7): [True: 0, False: 0] ------------------ 611| | /* register GCM ciphers */ 612| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 613| 0| ("Zhaoxin GCM accelerator was detected\n"); 614| 0| if (check_avx_movbe() && check_fast_pclmul()) { ------------------ | Branch (614:8): [True: 0, False: 0] | Branch (614:29): [True: 0, False: 0] ------------------ 615| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 616| 0| ("Zhaoxin GCM accelerator (AVX) was detected\n"); 617| 0| ret = 618| 0| gnutls_crypto_single_cipher_register 619| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 620| 0| &_gnutls_aes_gcm_pclmul_avx, 0); 621| 0| if (ret < 0) { ------------------ | Branch (621:9): [True: 0, False: 0] ------------------ 622| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 623| 0| } 624| | 625| 0| ret = 626| 0| gnutls_crypto_single_cipher_register 627| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 628| 0| &_gnutls_aes_gcm_pclmul_avx, 0); 629| 0| if (ret < 0) { ------------------ | Branch (629:9): [True: 0, False: 0] ------------------ 630| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 631| 0| } 632| | 633| 0| ret = 634| 0| gnutls_crypto_single_cipher_register 635| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 636| 0| &_gnutls_aes_gcm_pclmul_avx, 0); 637| 0| if (ret < 0) { ------------------ | Branch (637:9): [True: 0, False: 0] ------------------ 638| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 639| 0| } 640| 0| } else { 641| 0| ret = 642| 0| gnutls_crypto_single_cipher_register 643| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 644| 0| &_gnutls_aes_gcm_pclmul, 0); 645| 0| if (ret < 0) { ------------------ | Branch (645:9): [True: 0, False: 0] ------------------ 646| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 647| 0| } 648| | 649| 0| ret = 650| 0| gnutls_crypto_single_cipher_register 651| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 652| 0| &_gnutls_aes_gcm_pclmul, 0); 653| 0| if (ret < 0) { ------------------ | Branch (653:9): [True: 0, False: 0] ------------------ 654| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 655| 0| } 656| | 657| 0| ret = 658| 0| gnutls_crypto_single_cipher_register 659| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 660| 0| &_gnutls_aes_gcm_pclmul, 0); 661| 0| if (ret < 0) { ------------------ | Branch (661:9): [True: 0, False: 0] ------------------ 662| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 663| 0| } 664| 0| } 665| 0| } else 666| 0|# endif 667| 0| { 668| 0| ret = 669| 0| gnutls_crypto_single_cipher_register 670| 0| (GNUTLS_CIPHER_AES_128_GCM, 80, 671| 0| &_gnutls_aes_gcm_x86_aesni, 0); 672| 0| if (ret < 0) { ------------------ | Branch (672:8): [True: 0, False: 0] ------------------ 673| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 674| 0| } 675| | 676| 0| ret = 677| 0| gnutls_crypto_single_cipher_register 678| 0| (GNUTLS_CIPHER_AES_192_GCM, 80, 679| 0| &_gnutls_aes_gcm_x86_aesni, 0); 680| 0| if (ret < 0) { ------------------ | Branch (680:8): [True: 0, False: 0] ------------------ 681| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 682| 0| } 683| | 684| 0| ret = 685| 0| gnutls_crypto_single_cipher_register 686| 0| (GNUTLS_CIPHER_AES_256_GCM, 80, 687| 0| &_gnutls_aes_gcm_x86_aesni, 0); 688| 0| if (ret < 0) { ------------------ | Branch (688:8): [True: 0, False: 0] ------------------ 689| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 690| 0| } 691| 0| } 692| 0| } 693| | 694| 0| if (check_padlock(edx)) { ------------------ | Branch (694:6): [True: 0, False: 0] ------------------ 695| 0| _gnutls_debug_log("Padlock AES accelerator was detected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 696| 0| ret = 697| 0| gnutls_crypto_single_cipher_register 698| 0| (GNUTLS_CIPHER_AES_128_CBC, 80, &_gnutls_aes_padlock, 0); 699| 0| if (ret < 0) { ------------------ | Branch (699:7): [True: 0, False: 0] ------------------ 700| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 701| 0| } 702| | 703| 0| ret = 704| 0| gnutls_crypto_single_cipher_register 705| 0| (GNUTLS_CIPHER_AES_192_CBC, 80, &_gnutls_aes_padlock, 0); 706| 0| if (ret < 0) { ------------------ | Branch (706:7): [True: 0, False: 0] ------------------ 707| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 708| 0| } 709| | 710| | /* register GCM ciphers */ 711| 0| ret = 712| 0| gnutls_crypto_single_cipher_register 713| 0| (GNUTLS_CIPHER_AES_128_GCM, 90, 714| 0| &_gnutls_aes_gcm_padlock, 0); 715| 0| if (ret < 0) { ------------------ | Branch (715:7): [True: 0, False: 0] ------------------ 716| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 717| 0| } 718| | 719| 0| ret = 720| 0| gnutls_crypto_single_cipher_register 721| 0| (GNUTLS_CIPHER_AES_256_CBC, 80, &_gnutls_aes_padlock, 0); 722| 0| if (ret < 0) { ------------------ | Branch (722:7): [True: 0, False: 0] ------------------ 723| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 724| 0| } 725| | 726| 0| ret = 727| 0| gnutls_crypto_single_cipher_register 728| 0| (GNUTLS_CIPHER_AES_256_GCM, 90, 729| 0| &_gnutls_aes_gcm_padlock, 0); 730| 0| if (ret < 0) { ------------------ | Branch (730:7): [True: 0, False: 0] ------------------ 731| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 732| 0| } 733| 0| } 734| | 735| 0| if (!check_optimized_aes() && !check_padlock(edx)) ------------------ | Branch (735:6): [True: 0, False: 0] | Branch (735:32): [True: 0, False: 0] ------------------ 736| 0| _gnutls_priority_update_non_aesni(); 737| | 738| 0|# ifdef HAVE_LIBNETTLE 739| 0| phe = check_phe(edx); 740| | 741| 0| if (phe && check_phe_partial()) { ------------------ | Branch (741:6): [True: 0, False: 0] | Branch (741:13): [True: 0, False: 0] ------------------ 742| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 743| 0| ("Padlock SHA1 and SHA256 (partial) accelerator was detected\n"); 744| 0| if (check_phe_sha512(edx)) { ------------------ | Branch (744:7): [True: 0, False: 0] ------------------ 745| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 746| 0| ("Padlock SHA512 (partial) accelerator was detected\n"); 747| 0| ret = 748| 0| gnutls_crypto_single_digest_register 749| 0| (GNUTLS_DIG_SHA384, 80, &_gnutls_sha_padlock, 0); 750| 0| if (ret < 0) { ------------------ | Branch (750:8): [True: 0, False: 0] ------------------ 751| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 752| 0| } 753| | 754| 0| ret = 755| 0| gnutls_crypto_single_digest_register 756| 0| (GNUTLS_DIG_SHA512, 80, &_gnutls_sha_padlock, 0); 757| 0| if (ret < 0) { ------------------ | Branch (757:8): [True: 0, False: 0] ------------------ 758| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 759| 0| } 760| | 761| 0| ret = 762| 0| gnutls_crypto_single_mac_register 763| 0| (GNUTLS_MAC_SHA384, 80, 764| 0| &_gnutls_hmac_sha_padlock, 0); 765| 0| if (ret < 0) { ------------------ | Branch (765:8): [True: 0, False: 0] ------------------ 766| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 767| 0| } 768| | 769| 0| ret = 770| 0| gnutls_crypto_single_mac_register 771| 0| (GNUTLS_MAC_SHA512, 80, 772| 0| &_gnutls_hmac_sha_padlock, 0); 773| 0| if (ret < 0) { ------------------ | Branch (773:8): [True: 0, False: 0] ------------------ 774| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 775| 0| } 776| 0| } 777| | 778| 0| ret = 779| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA1, 780| 0| 90, 781| 0| &_gnutls_sha_padlock, 782| 0| 0); 783| 0| if (ret < 0) { ------------------ | Branch (783:7): [True: 0, False: 0] ------------------ 784| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 785| 0| } 786| | 787| 0| ret = 788| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA224, 789| 0| 90, 790| 0| &_gnutls_sha_padlock, 791| 0| 0); 792| 0| if (ret < 0) { ------------------ | Branch (792:7): [True: 0, False: 0] ------------------ 793| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 794| 0| } 795| | 796| 0| ret = 797| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA256, 798| 0| 90, 799| 0| &_gnutls_sha_padlock, 800| 0| 0); 801| 0| if (ret < 0) { ------------------ | Branch (801:7): [True: 0, False: 0] ------------------ 802| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 803| 0| } 804| | 805| 0| ret = 806| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA1, 807| 0| 90, 808| 0| &_gnutls_hmac_sha_padlock, 809| 0| 0); 810| 0| if (ret < 0) { ------------------ | Branch (810:7): [True: 0, False: 0] ------------------ 811| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 812| 0| } 813| | 814| | /* we don't register MAC_SHA224 because it is not used by TLS */ 815| | 816| 0| ret = 817| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA256, 818| 0| 90, 819| 0| &_gnutls_hmac_sha_padlock, 820| 0| 0); 821| 0| if (ret < 0) { ------------------ | Branch (821:7): [True: 0, False: 0] ------------------ 822| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 823| 0| } 824| 0| } else if (phe) { ------------------ | Branch (824:13): [True: 0, False: 0] ------------------ 825| | /* Original padlock PHE. Does not support incremental operations. 826| | */ 827| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 828| 0| ("Padlock SHA1 and SHA256 accelerator was detected\n"); 829| 0| ret = 830| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA1, 831| 0| 90, 832| 0| &_gnutls_sha_padlock_oneshot, 833| 0| 0); 834| 0| if (ret < 0) { ------------------ | Branch (834:7): [True: 0, False: 0] ------------------ 835| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 836| 0| } 837| | 838| 0| ret = 839| 0| gnutls_crypto_single_digest_register(GNUTLS_DIG_SHA256, 840| 0| 90, 841| 0| &_gnutls_sha_padlock_oneshot, 842| 0| 0); 843| 0| if (ret < 0) { ------------------ | Branch (843:7): [True: 0, False: 0] ------------------ 844| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 845| 0| } 846| | 847| 0| ret = 848| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA1, 849| 0| 90, 850| 0| &_gnutls_hmac_sha_padlock_oneshot, 851| 0| 0); 852| 0| if (ret < 0) { ------------------ | Branch (852:7): [True: 0, False: 0] ------------------ 853| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 854| 0| } 855| | 856| 0| ret = 857| 0| gnutls_crypto_single_mac_register(GNUTLS_MAC_SHA256, 858| 0| 90, 859| 0| &_gnutls_hmac_sha_padlock_oneshot, 860| 0| 0); 861| 0| if (ret < 0) { ------------------ | Branch (861:7): [True: 0, False: 0] ------------------ 862| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 863| 0| } 864| 0| } 865| 0|# endif 866| | 867| 0| return; 868| 0|} x86-common.c:check_zhaoxin: 364| 2|{ 365| 2| unsigned int a, b, c, d; 366| | 367| 2| if (!__get_cpuid(0, &a, &b, &c, &d)) ------------------ | Branch (367:6): [True: 0, False: 2] ------------------ 368| 0| return 0; 369| | 370| | /* Zhaoxin and VIA CPU was detected */ 371| 2| if ((memcmp(&b, "Cent", 4) == 0 && ------------------ | Branch (371:7): [True: 0, False: 2] ------------------ 372| 2| memcmp(&d, "aurH", 4) == 0 && ------------------ | Branch (372:7): [True: 0, False: 0] ------------------ 373| 2| memcmp(&c, "auls", 4) == 0) || ------------------ | Branch (373:7): [True: 0, False: 0] ------------------ 374| 2| (memcmp(&b, " Sh", 4) == 0 && ------------------ | Branch (374:7): [True: 0, False: 2] ------------------ 375| 2| memcmp(&d, "angh", 4) == 0 && memcmp(&c, "ai ", 4) == 0)) { ------------------ | Branch (375:7): [True: 0, False: 0] | Branch (375:37): [True: 0, False: 0] ------------------ 376| 0| return 1; 377| 0| } 378| | 379| 2| return 0; 380| 2|} _gnutls_register_fork_handler: 51| 2|{ 52| 2| if (__register_atfork(NULL, NULL, fork_handler, __dso_handle) != 0) ------------------ | Branch (52:6): [True: 0, False: 2] ------------------ 53| 0| return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 54| 2| return 0; 55| 2|} gnutls_crypto_single_cipher_register: 180| 36|{ 181| | /* we override const in case free_s is set */ 182| 36| return _algo_register(&glob_cl, algorithm, priority, (void *)s, free_s); 183| 36|} gnutls_crypto_single_mac_register: 359| 10|{ 360| 10| return _algo_register(&glob_ml, algorithm, priority, (void *)s, free_s); 361| 10|} gnutls_crypto_single_digest_register: 394| 10|{ 395| 10| return _algo_register(&glob_dl, algorithm, priority, (void *)s, free_s); 396| 10|} crypto-backend.c:_algo_register: 52| 56|{ 53| 56| algo_list *cl; 54| 56| algo_list *last_cl = al; 55| 56| int ret; 56| | 57| 56| if (al == NULL) { ------------------ | Branch (57:6): [True: 0, False: 56] ------------------ 58| 0| ret = gnutls_assert_val(GNUTLS_E_INVALID_REQUEST); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 59| 0| goto cleanup; 60| 0| } 61| | 62| | /* look if there is any cipher with lowest priority. In that case do not add. 63| | */ 64| 56| cl = al; 65| 258| while (cl && cl->alg_data) { ------------------ | Branch (65:9): [True: 258, False: 0] | Branch (65:15): [True: 214, False: 44] ------------------ 66| 214| if (cl->algorithm == algorithm) { ------------------ | Branch (66:7): [True: 12, False: 202] ------------------ 67| 12| if (cl->priority < priority) { ------------------ | Branch (67:8): [True: 0, False: 12] ------------------ 68| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 69| 0| ret = GNUTLS_E_CRYPTO_ALREADY_REGISTERED; ------------------ | | 3522| 0|# define GNUTLS_E_CRYPTO_ALREADY_REGISTERED GNUTLS_E_ALREADY_REGISTERED | | ------------------ | | | | 3523| 0|# define GNUTLS_E_ALREADY_REGISTERED -209 | | ------------------ ------------------ 70| 0| goto cleanup; 71| 12| } else { 72| | /* the current has higher priority -> overwrite */ 73| 12| cl->algorithm = algorithm; 74| 12| cl->priority = priority; 75| 12| cl->alg_data = s; 76| 12| cl->free_alg_data = free_s; 77| 12| return 0; 78| 12| } 79| 12| } 80| 202| cl = cl->next; 81| 202| if (cl) ------------------ | Branch (81:7): [True: 202, False: 0] ------------------ 82| 202| last_cl = cl; 83| 202| } 84| | 85| 44| cl = gnutls_calloc(1, sizeof(cipher_list)); 86| | 87| 44| if (cl == NULL) { ------------------ | Branch (87:6): [True: 0, False: 44] ------------------ 88| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 89| 0| ret = GNUTLS_E_MEMORY_ERROR; ------------------ | | 3406| 0|# define GNUTLS_E_MEMORY_ERROR -25 ------------------ 90| 0| goto cleanup; 91| 0| } 92| | 93| 44| last_cl->algorithm = algorithm; 94| 44| last_cl->priority = priority; 95| 44| last_cl->alg_data = s; 96| 44| last_cl->free_alg_data = free_s; 97| 44| last_cl->next = cl; 98| | 99| 44| return 0; 100| 0| cleanup: 101| 0| if (free_s) ------------------ | Branch (101:6): [True: 0, False: 0] ------------------ 102| 0| gnutls_free(s); ------------------ | | 2296| 0|# define gnutls_free(a) gnutls_free((void *) (a)), a=NULL ------------------ 103| 0| return ret; 104| 44|} global.c:_gnutls_switch_lib_state: 48| 4|{ 49| | /* Once into zombie state no errors can change us */ 50| 4| _gnutls_lib_state = state; 51| 4|} _gnutls_global_init_skip: 60| 2|{ 61| 2| return 0; 62| 2|} global.c:lib_init: 488| 2|{ 489| 2| int ret; 490| 2| const char *e; 491| | 492| 2| if (_gnutls_global_init_skip() != 0) ------------------ | Branch (492:6): [True: 0, False: 2] ------------------ 493| 0| return; 494| | 495| 2| e = secure_getenv("GNUTLS_NO_IMPLICIT_INIT"); 496| 2| if (e != NULL) { ------------------ | Branch (496:6): [True: 0, False: 2] ------------------ 497| 0| ret = atoi(e); 498| 0| if (ret == 1) ------------------ | Branch (498:7): [True: 0, False: 0] ------------------ 499| 0| return; 500| 0| } 501| | 502| 2| e = secure_getenv("GNUTLS_NO_EXPLICIT_INIT"); 503| 2| if (e != NULL) { ------------------ | Branch (503:6): [True: 0, False: 2] ------------------ 504| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 505| 0| ("GNUTLS_NO_EXPLICIT_INIT is deprecated; use GNUTLS_NO_IMPLICIT_INIT\n"); 506| 0| ret = atoi(e); 507| 0| if (ret == 1) ------------------ | Branch (507:7): [True: 0, False: 0] ------------------ 508| 0| return; 509| 0| } 510| | 511| 2| ret = _gnutls_global_init(1); 512| 2| if (ret < 0) { ------------------ | Branch (512:6): [True: 0, False: 2] ------------------ 513| 0| fprintf(stderr, "Error in GnuTLS initialization: %s\n", 514| 0| gnutls_strerror(ret)); 515| 0| _gnutls_switch_lib_state(LIB_STATE_ERROR); 516| 0| } 517| 2|} global.c:_gnutls_global_init: 228| 2|{ 229| 2| int ret = 0, res; 230| 2| int level; 231| 2| const char *e; 232| | 233| 2| if (!constructor) { ------------------ | Branch (233:6): [True: 0, False: 2] ------------------ 234| 0| ret = gnutls_static_mutex_lock(&global_init_mutex); ------------------ | | 45| 0| (unlikely(glthread_lock_lock(LOCK)) ? \ | | ------------------ | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 46| 0| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 235| 0| if (ret < 0) { ------------------ | Branch (235:7): [True: 0, False: 0] ------------------ 236| 0| return gnutls_assert_val(ret); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 237| 0| } 238| 0| } 239| | 240| 2| _gnutls_init++; 241| 2| if (_gnutls_init > 1) { ------------------ | Branch (241:6): [True: 0, False: 2] ------------------ 242| 0| ret = _gnutls_init_ret; 243| 0| goto out; 244| 0| } 245| | 246| 2| _gnutls_switch_lib_state(LIB_STATE_INIT); 247| | 248| 2| e = secure_getenv("GNUTLS_DEBUG_LEVEL"); 249| 2| if (e != NULL) { ------------------ | Branch (249:6): [True: 0, False: 2] ------------------ 250| 0| level = atoi(e); 251| 0| gnutls_global_set_log_level(level); 252| 0| if (_gnutls_log_func == NULL) ------------------ | Branch (252:7): [True: 0, False: 0] ------------------ 253| 0| gnutls_global_set_log_function(default_log_func); 254| 0| _gnutls_debug_log("Enabled GnuTLS " VERSION " logging...\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 255| 0| } 256| | 257| 2|#ifdef HAVE_DCGETTEXT 258| 2| bindtextdomain(PACKAGE, LOCALEDIR); ------------------ | | 1835| 2|#define PACKAGE "gnutls" ------------------ 259| 2|#endif 260| | 261| 2| res = gnutls_crypto_init(); 262| 2| if (res != 0) { ------------------ | Branch (262:6): [True: 0, False: 2] ------------------ 263| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 264| 0| ret = GNUTLS_E_CRYPTO_INIT_FAILED; ------------------ | | 3561| 0|# define GNUTLS_E_CRYPTO_INIT_FAILED -318 ------------------ 265| 0| goto out; 266| 0| } 267| | 268| 2| ret = _gnutls_system_key_init(); 269| 2| if (ret != 0) { ------------------ | Branch (269:6): [True: 0, False: 2] ------------------ 270| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 271| 0| } 272| | 273| | /* initialize ASN.1 parser 274| | */ 275| 2| if (asn1_check_version(GNUTLS_MIN_LIBTASN1_VERSION) == NULL) { ------------------ | | 45| 2|#define GNUTLS_MIN_LIBTASN1_VERSION "0.3.4" ------------------ | Branch (275:6): [True: 0, False: 2] ------------------ 276| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 277| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 278| 0| ("Checking for libtasn1 failed: %s < %s\n", 279| 0| asn1_check_version(NULL), GNUTLS_MIN_LIBTASN1_VERSION); 280| 0| ret = GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY; ------------------ | | 3512| 0|# define GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY -203 ------------------ 281| 0| goto out; 282| 0| } 283| | 284| 2| _gnutls_pkix1_asn = NULL; 285| 2| res = asn1_array2tree(pkix_asn1_tab, &_gnutls_pkix1_asn, NULL); 286| 2| if (res != ASN1_SUCCESS) { ------------------ | | 116| 2|# define ASN1_SUCCESS 0 ------------------ | Branch (286:6): [True: 0, False: 2] ------------------ 287| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 288| 0| ret = _gnutls_asn2err(res); 289| 0| goto out; 290| 0| } 291| | 292| 2| res = asn1_array2tree(gnutls_asn1_tab, &_gnutls_gnutls_asn, NULL); 293| 2| if (res != ASN1_SUCCESS) { ------------------ | | 116| 2|# define ASN1_SUCCESS 0 ------------------ | Branch (293:6): [True: 0, False: 2] ------------------ 294| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 295| 0| ret = _gnutls_asn2err(res); 296| 0| goto out; 297| 0| } 298| | 299| | /* Initialize the random generator */ 300| 2| ret = _gnutls_rnd_preinit(); 301| 2| if (ret < 0) { ------------------ | Branch (301:6): [True: 0, False: 2] ------------------ 302| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 303| 0| goto out; 304| 0| } 305| | 306| | /* Initialize the default TLS extensions */ 307| 2| ret = _gnutls_hello_ext_init(); 308| 2| if (ret < 0) { ------------------ | Branch (308:6): [True: 0, False: 2] ------------------ 309| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 310| 0| goto out; 311| 0| } 312| | 313| 2| ret = gnutls_system_global_init(); 314| 2| if (ret < 0) { ------------------ | Branch (314:6): [True: 0, False: 2] ------------------ 315| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 316| 0| goto out; 317| 0| } 318| | 319| 2|#ifndef _WIN32 320| 2| ret = _gnutls_register_fork_handler(); 321| 2| if (ret < 0) { ------------------ | Branch (321:6): [True: 0, False: 2] ------------------ 322| 0| gnutls_assert(); ------------------ | | 33| 0|# define gnutls_assert() _gnutls_assert_log( "ASSERT: %s[%s]:%d\n", __FILE__,__func__,__LINE__); | | ------------------ | | | | 140| 0|# define _gnutls_assert_log(...) LEVEL(3, __VA_ARGS__) | | | | ------------------ | | | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | | | ------------------ | | | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | | | ------------------ | | | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | | | ------------------ | | | | | | | Branch (137:45): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 323| 0| goto out; 324| 0| } 325| 2|#endif 326| | 327| |#ifdef ENABLE_FIPS140 328| | res = _gnutls_fips_mode_enabled(); 329| | /* res == 1 -> fips140-2 mode enabled 330| | * res == 2 -> only self checks performed - but no failure 331| | * res == not in fips140 mode 332| | */ 333| | if (res != 0) { 334| | _gnutls_debug_log("FIPS140-2 mode: %d\n", res); 335| | _gnutls_priority_update_fips(); 336| | 337| | /* first round of self checks, these are done on the 338| | * nettle algorithms which are used internally */ 339| | _gnutls_switch_lib_state(LIB_STATE_SELFTEST); 340| | ret = _gnutls_fips_perform_self_checks1(); 341| | if (ret < 0) { 342| | _gnutls_switch_lib_state(LIB_STATE_ERROR); 343| | _gnutls_audit_log(NULL, 344| | "FIPS140-2 self testing part1 failed\n"); 345| | if (res != 2) { 346| | gnutls_assert(); 347| | goto out; 348| | } 349| | } 350| | } 351| |#endif 352| | 353| 2| _gnutls_register_accel_crypto(); 354| 2| _gnutls_cryptodev_init(); 355| 2| _gnutls_afalg_init(); 356| | 357| |#ifdef ENABLE_FIPS140 358| | /* These self tests are performed on the overridden algorithms 359| | * (e.g., AESNI overridden AES). They are after _gnutls_register_accel_crypto() 360| | * intentionally */ 361| | if (res != 0) { 362| | _gnutls_switch_lib_state(LIB_STATE_SELFTEST); 363| | ret = _gnutls_fips_perform_self_checks2(); 364| | if (ret < 0) { 365| | _gnutls_switch_lib_state(LIB_STATE_ERROR); 366| | _gnutls_audit_log(NULL, 367| | "FIPS140-2 self testing part 2 failed\n"); 368| | if (res != 2) { 369| | gnutls_assert(); 370| | goto out; 371| | } 372| | } 373| | _gnutls_fips_mode_reset_zombie(); 374| | } 375| |#endif 376| 2| _gnutls_prepare_to_load_system_priorities(); 377| 2| _gnutls_switch_lib_state(LIB_STATE_OPERATIONAL); 378| 2| ret = 0; 379| | 380| 2| out: 381| 2| _gnutls_init_ret = ret; 382| 2| if (!constructor) { ------------------ | Branch (382:6): [True: 0, False: 2] ------------------ 383| 0| (void)gnutls_static_mutex_unlock(&global_init_mutex); ------------------ | | 49| 0| (unlikely(glthread_lock_unlock(LOCK)) ? \ | | ------------------ | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 50| 0| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 384| 0| } 385| 2| return ret; 386| 2|} _gnutls_hello_ext_init: 477| 2|{ 478| 2| return GNUTLS_E_SUCCESS; ------------------ | | 3388| 2|# define GNUTLS_E_SUCCESS 0 ------------------ 479| 2|} _asn1_str_cat: 33| 532|{ 34| 532| size_t str_size = strlen (src); 35| 532| size_t dest_size = strlen (dest); 36| | 37| 532| if (dest_tot_size - dest_size > str_size) ------------------ | Branch (37:7): [True: 532, False: 0] ------------------ 38| 532| { 39| 532| strcat (dest, src); 40| 532| } 41| 0| else 42| 0| { 43| 0| if (dest_tot_size > dest_size) ------------------ | Branch (43:11): [True: 0, False: 0] ------------------ 44| 0| { 45| 0| strncat (dest, src, (dest_tot_size - dest_size) - 1); 46| 0| dest[dest_tot_size - 1] = 0; 47| 0| } 48| 0| } 49| 532|} _asn1_str_cpy: 54| 1.43k|{ 55| 1.43k| size_t str_size = strlen (src); 56| | 57| 1.43k| if (dest_tot_size > str_size) ------------------ | Branch (57:7): [True: 1.43k, False: 0] ------------------ 58| 1.43k| { 59| 1.43k| strcpy (dest, src); 60| 1.43k| return str_size; 61| 1.43k| } 62| 0| else 63| 0| { 64| 0| if (dest_tot_size > 0) ------------------ | Branch (64:11): [True: 0, False: 0] ------------------ 65| 0| { 66| 0| str_size = dest_tot_size - 1; 67| 0| memcpy (dest, src, str_size); 68| 0| dest[str_size] = 0; 69| 0| return str_size; 70| 0| } 71| 0| else 72| 0| return 0; 73| 0| } 74| 1.43k|} parser_aux.c:type_field: 179| 5.64k|{ 180| 5.64k| return (ntype & 0xff); 181| 5.64k|} structure.c:convert_old_type: 186| 1.14k|{ 187| 1.14k| unsigned int type = ntype & 0xff; 188| 1.14k| if (type == ASN1_ETYPE_TIME) ------------------ | | 172| 1.14k|# define ASN1_ETYPE_TIME 17 ------------------ | Branch (188:7): [True: 0, False: 1.14k] ------------------ 189| 0| { 190| 0| if (ntype & CONST_UTC) ------------------ | | 160| 0|# define CONST_UTC (1U<<24) ------------------ | Branch (190:11): [True: 0, False: 0] ------------------ 191| 0| type = ASN1_ETYPE_UTC_TIME; ------------------ | | 244| 0|# define ASN1_ETYPE_UTC_TIME 36 ------------------ 192| 0| else 193| 0| type = ASN1_ETYPE_GENERALIZED_TIME; ------------------ | | 245| 0|# define ASN1_ETYPE_GENERALIZED_TIME 37 ------------------ 194| | 195| 0| ntype &= ~(CONST_UTC | CONST_GENERALIZED); ------------------ | | 160| 0|# define CONST_UTC (1U<<24) ------------------ ntype &= ~(CONST_UTC | CONST_GENERALIZED); ------------------ | | 159| 0|# define CONST_GENERALIZED (1U<<23) ------------------ 196| 0| ntype &= 0xffffff00; 197| 0| ntype |= type; 198| | 199| 0| return ntype; 200| 0| } 201| 1.14k| else 202| 1.14k| return ntype; 203| 1.14k|} _asn1_add_static_node: 66| 1.14k|{ 67| 1.14k| list_type *p; 68| 1.14k| asn1_node punt; 69| | 70| 1.14k| punt = calloc (1, sizeof (struct asn1_node_st)); 71| 1.14k| if (punt == NULL) ------------------ | Branch (71:7): [True: 0, False: 1.14k] ------------------ 72| 0| return NULL; 73| | 74| 1.14k| p = malloc (sizeof (list_type)); 75| 1.14k| if (p == NULL) ------------------ | Branch (75:7): [True: 0, False: 1.14k] ------------------ 76| 0| { 77| 0| free (punt); 78| 0| return NULL; 79| 0| } 80| | 81| 1.14k| p->node = punt; 82| 1.14k| p->next = *e_list; 83| 1.14k| *e_list = p; 84| | 85| 1.14k| punt->type = type; 86| | 87| 1.14k| return punt; 88| 1.14k|} asn1_find_node: 122| 266|{ 123| 266| asn1_node_const p; 124| 266| char *n_end, n[ASN1_MAX_NAME_SIZE + 1]; 125| 266| const char *n_start; 126| 266| unsigned int nsize; 127| 266| unsigned int nhash; 128| | 129| 266| if (pointer == NULL) ------------------ | Branch (129:7): [True: 0, False: 266] ------------------ 130| 0| return NULL; 131| | 132| 266| if (name == NULL) ------------------ | Branch (132:7): [True: 0, False: 266] ------------------ 133| 0| return NULL; 134| | 135| 266| p = pointer; 136| 266| n_start = name; 137| | 138| 266| if (name[0] == '?' && name[1] == 'C' && p->name[0] == '?') ------------------ | Branch (138:7): [True: 0, False: 266] | Branch (138:25): [True: 0, False: 0] | Branch (138:43): [True: 0, False: 0] ------------------ 139| 0| { /* ?CURRENT */ 140| 0| n_start = strchr (n_start, '.'); 141| 0| if (n_start) ------------------ | Branch (141:11): [True: 0, False: 0] ------------------ 142| 0| n_start++; 143| 0| } 144| 266| else if (p->name[0] != 0) ------------------ | Branch (144:12): [True: 266, False: 0] ------------------ 145| 266| { /* has *pointer got a name ? */ 146| 266| n_end = strchr (n_start, '.'); /* search the first dot */ 147| 266| if (n_end) ------------------ | Branch (147:11): [True: 266, False: 0] ------------------ 148| 266| { 149| 266| nsize = n_end - n_start; 150| 266| if (nsize >= sizeof (n)) ------------------ | Branch (150:8): [True: 0, False: 266] ------------------ 151| 0| return NULL; 152| | 153| 266| memcpy (n, n_start, nsize); 154| 266| n[nsize] = 0; 155| 266| n_start = n_end; 156| 266| n_start++; 157| | 158| 266| nhash = _asn1_hash_name (n); 159| 266| } 160| 0| else 161| 0| { 162| 0| _asn1_str_cpy (n, sizeof (n), n_start); 163| 0| nhash = _asn1_hash_name (n); 164| | 165| 0| n_start = NULL; 166| 0| } 167| | 168| 266| while (p) ------------------ | Branch (168:14): [True: 266, False: 0] ------------------ 169| 266| { 170| 266| if (nhash == p->name_hash && (!strcmp (p->name, n))) ------------------ | Branch (170:8): [True: 266, False: 0] | Branch (170:33): [True: 266, False: 0] ------------------ 171| 266| break; 172| 0| else 173| 0| p = p->right; 174| 266| } /* while */ 175| | 176| 266| if (p == NULL) ------------------ | Branch (176:11): [True: 0, False: 266] ------------------ 177| 0| return NULL; 178| 266| } 179| 0| else 180| 0| { /* *pointer doesn't have a name */ 181| 0| if (n_start[0] == 0) ------------------ | Branch (181:11): [True: 0, False: 0] ------------------ 182| 0| return (asn1_node) p; 183| 0| } 184| | 185| 532| while (n_start) ------------------ | Branch (185:10): [True: 266, False: 266] ------------------ 186| 266| { /* Has the end of NAME been reached? */ 187| 266| n_end = strchr (n_start, '.'); /* search the next dot */ 188| 266| if (n_end) ------------------ | Branch (188:11): [True: 0, False: 266] ------------------ 189| 0| { 190| 0| nsize = n_end - n_start; 191| 0| if (nsize >= sizeof (n)) ------------------ | Branch (191:8): [True: 0, False: 0] ------------------ 192| 0| return NULL; 193| | 194| 0| memcpy (n, n_start, nsize); 195| 0| n[nsize] = 0; 196| 0| n_start = n_end; 197| 0| n_start++; 198| | 199| 0| nhash = _asn1_hash_name (n); 200| 0| } 201| 266| else 202| 266| { 203| 266| _asn1_str_cpy (n, sizeof (n), n_start); 204| 266| nhash = _asn1_hash_name (n); 205| 266| n_start = NULL; 206| 266| } 207| | 208| 266| if (p->down == NULL) ------------------ | Branch (208:11): [True: 0, False: 266] ------------------ 209| 0| return NULL; 210| | 211| 266| p = p->down; 212| 266| if (p == NULL) ------------------ | Branch (212:11): [True: 0, False: 266] ------------------ 213| 0| return NULL; 214| | 215| | /* The identifier "?LAST" indicates the last element 216| | in the right chain. */ 217| 266| if (n[0] == '?' && n[1] == 'L') /* ?LAST */ ------------------ | Branch (217:11): [True: 0, False: 266] | Branch (217:26): [True: 0, False: 0] ------------------ 218| 0| { 219| 0| while (p->right) ------------------ | Branch (219:11): [True: 0, False: 0] ------------------ 220| 0| p = p->right; 221| 0| } 222| 266| else 223| 266| { /* no "?LAST" */ 224| 11.1k| while (p) ------------------ | Branch (224:11): [True: 11.1k, False: 0] ------------------ 225| 11.1k| { 226| 11.1k| if (p->name_hash == nhash && !strcmp (p->name, n)) ------------------ | Branch (226:12): [True: 266, False: 10.8k] | Branch (226:37): [True: 266, False: 0] ------------------ 227| 266| break; 228| 10.8k| else 229| 10.8k| p = p->right; 230| 11.1k| } 231| 266| } 232| 266| if (p == NULL) ------------------ | Branch (232:11): [True: 0, False: 266] ------------------ 233| 0| return NULL; 234| 266| } /* while */ 235| | 236| 266| return (asn1_node) p; 237| 266|} _asn1_set_value: 252| 462|{ 253| 462| if (node == NULL) ------------------ | Branch (253:7): [True: 0, False: 462] ------------------ 254| 0| return node; 255| 462| if (node->value) ------------------ | Branch (255:7): [True: 0, False: 462] ------------------ 256| 0| { 257| 0| if (node->value != node->small_value) ------------------ | Branch (257:11): [True: 0, False: 0] ------------------ 258| 0| free (node->value); 259| 0| node->value = NULL; 260| 0| node->value_len = 0; 261| 0| } 262| | 263| 462| if (!len) ------------------ | Branch (263:7): [True: 0, False: 462] ------------------ 264| 0| return node; 265| | 266| 462| if (len < sizeof (node->small_value)) ------------------ | Branch (266:7): [True: 314, False: 148] ------------------ 267| 314| { 268| 314| node->value = node->small_value; 269| 314| } 270| 148| else 271| 148| { 272| 148| node->value = malloc (len); 273| 148| if (node->value == NULL) ------------------ | Branch (273:11): [True: 0, False: 148] ------------------ 274| 0| return NULL; 275| 148| } 276| 462| node->value_len = len; 277| | 278| 462| memcpy (node->value, value, len); 279| 462| return node; 280| 462|} _asn1_set_name: 409| 898|{ 410| 898| if (node == NULL) ------------------ | Branch (410:7): [True: 0, False: 898] ------------------ 411| 0| return node; 412| | 413| 898| _asn1_str_cpy (node->name, sizeof (node->name), name ? name : ""); ------------------ | Branch (413:51): [True: 898, False: 0] ------------------ 414| 898| node->name_hash = _asn1_hash_name (node->name); 415| | 416| 898| return node; 417| 898|} _asn1_set_right: 457| 714|{ 458| 714| if (node == NULL) ------------------ | Branch (458:7): [True: 0, False: 714] ------------------ 459| 0| return node; 460| 714| node->right = right; 461| 714| if (right) ------------------ | Branch (461:7): [True: 714, False: 0] ------------------ 462| 714| right->left = node; 463| 714| return node; 464| 714|} _asn1_find_up: 523| 2.12k|{ 524| 2.12k| asn1_node_const p; 525| | 526| 2.12k| if (node == NULL) ------------------ | Branch (526:7): [True: 0, False: 2.12k] ------------------ 527| 0| return NULL; 528| | 529| 2.12k| p = node; 530| | 531| 5.69k| while ((p->left != NULL) && (p->left->right == p)) ------------------ | Branch (531:10): [True: 5.69k, False: 0] | Branch (531:31): [True: 3.57k, False: 2.12k] ------------------ 532| 3.57k| p = p->left; 533| | 534| 2.12k| return p->left; 535| 2.12k|} _asn1_delete_list: 581| 4|{ 582| 4| list_type *p; 583| | 584| 1.14k| while (e_list) ------------------ | Branch (584:10): [True: 1.14k, False: 4] ------------------ 585| 1.14k| { 586| 1.14k| p = e_list; 587| 1.14k| e_list = e_list->next; 588| 1.14k| free (p); 589| 1.14k| } 590| 4|} _asn1_change_integer_value: 662| 4|{ 663| 4| asn1_node p; 664| 4| unsigned char val[SIZEOF_UNSIGNED_LONG_INT]; 665| 4| unsigned char val2[SIZEOF_UNSIGNED_LONG_INT + 1]; 666| 4| int len; 667| | 668| 4| if (node == NULL) ------------------ | Branch (668:7): [True: 0, False: 4] ------------------ 669| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 670| | 671| 4| p = node; 672| 1.14k| while (p) ------------------ | Branch (672:10): [True: 1.14k, False: 4] ------------------ 673| 1.14k| { 674| 1.14k| if ((type_field (p->type) == ASN1_ETYPE_INTEGER) ------------------ | | 217| 1.14k|# define ASN1_ETYPE_INTEGER 3 ------------------ | Branch (674:11): [True: 124, False: 1.01k] ------------------ 675| 1.14k| && (p->type & CONST_ASSIGN)) ------------------ | | 166| 124|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (675:7): [True: 0, False: 124] ------------------ 676| 0| { 677| 0| if (p->value) ------------------ | Branch (677:8): [True: 0, False: 0] ------------------ 678| 0| { 679| 0| _asn1_convert_integer (p->value, val, sizeof (val), &len); 680| 0| asn1_octet_der (val, len, val2, &len); 681| 0| _asn1_set_value (p, val2, len); 682| 0| } 683| 0| } 684| | 685| 1.14k| if (p->down) ------------------ | Branch (685:11): [True: 424, False: 718] ------------------ 686| 424| { 687| 424| p = p->down; 688| 424| } 689| 718| else 690| 718| { 691| 718| if (p == node) ------------------ | Branch (691:8): [True: 0, False: 718] ------------------ 692| 0| p = NULL; 693| 718| else if (p->right) ------------------ | Branch (693:13): [True: 392, False: 326] ------------------ 694| 392| p = p->right; 695| 326| else 696| 326| { 697| 424| while (1) ------------------ | Branch (697:15): [Folded - Ignored] ------------------ 698| 424| { 699| 424| p = _asn1_find_up (p); 700| 424| if (p == node) ------------------ | Branch (700:9): [True: 4, False: 420] ------------------ 701| 4| { 702| 4| p = NULL; 703| 4| break; 704| 4| } 705| 420| if (p && p->right) ------------------ | Branch (705:9): [True: 420, False: 0] | Branch (705:14): [True: 322, False: 98] ------------------ 706| 322| { 707| 322| p = p->right; 708| 322| break; 709| 322| } 710| 420| } 711| 326| } 712| 718| } 713| 1.14k| } 714| | 715| 4| return ASN1_SUCCESS; ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ 716| 4|} _asn1_expand_object_id: 731| 4|{ 732| 4| asn1_node p, p2, p3, p4, p5; 733| 4| char name_root[ASN1_MAX_NAME_SIZE], name2[2 * ASN1_MAX_NAME_SIZE + 1]; 734| 4| int move, tlen, tries; 735| 4| unsigned max_constants; 736| | 737| 4| if (node == NULL) ------------------ | Branch (737:7): [True: 0, False: 4] ------------------ 738| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 739| | 740| 4| _asn1_str_cpy (name_root, sizeof (name_root), node->name); 741| | 742| 4| p = node; 743| 4| move = DOWN; ------------------ | | 131| 4|# define DOWN 3 ------------------ 744| 4| tries = 0; 745| | 746| 1.56k| while (!((p == node) && (move == UP))) ------------------ | | 129| 8|# define UP 1 ------------------ | Branch (746:12): [True: 8, False: 1.55k] | Branch (746:27): [True: 4, False: 4] ------------------ 747| 1.56k| { 748| 1.56k| if (move != UP) ------------------ | | 129| 1.56k|# define UP 1 ------------------ | Branch (748:11): [True: 1.14k, False: 420] ------------------ 749| 1.14k| { 750| 1.14k| if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) ------------------ | | 226| 1.14k|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (750:8): [True: 68, False: 1.07k] ------------------ 751| 1.14k| && (p->type & CONST_ASSIGN)) ------------------ | | 166| 68|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (751:11): [True: 2, False: 66] ------------------ 752| 2| { 753| 2| p2 = p->down; 754| 2| if (p2 && (type_field (p2->type) == ASN1_ETYPE_CONSTANT)) ------------------ | | 215| 2|# define ASN1_ETYPE_CONSTANT 1 ------------------ | Branch (754:12): [True: 2, False: 0] | Branch (754:18): [True: 2, False: 0] ------------------ 755| 2| { 756| 2| if (p2->value && !c_isdigit (p2->value[0])) ------------------ | Branch (756:9): [True: 2, False: 0] | Branch (756:22): [True: 0, False: 2] ------------------ 757| 0| { 758| 0| _asn1_str_cpy (name2, sizeof (name2), name_root); 759| 0| _asn1_str_cat (name2, sizeof (name2), "."); 760| 0| _asn1_str_cat (name2, sizeof (name2), 761| 0| (char *) p2->value); 762| 0| p3 = asn1_find_node (node, name2); 763| 0| if (!p3 || _asn1_is_up (p2, p3) || ------------------ | Branch (763:13): [True: 0, False: 0] | Branch (763:20): [True: 0, False: 0] ------------------ 764| 0| (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID) || ------------------ | | 226| 0|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (764:6): [True: 0, False: 0] ------------------ 765| 0| !(p3->type & CONST_ASSIGN)) ------------------ | | 166| 0|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (765:6): [True: 0, False: 0] ------------------ 766| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 767| | 768| 0| _asn1_set_down (p, p2->right); 769| 0| if (p2->down) ------------------ | Branch (769:13): [True: 0, False: 0] ------------------ 770| 0| _asn1_delete_structure (*list, &p2->down, 0); 771| 0| _asn1_delete_node_from_list (*list, p2); 772| 0| _asn1_remove_node (p2, 0); 773| 0| p2 = p; 774| 0| p4 = p3->down; 775| 0| max_constants = 0; 776| 0| while (p4) ------------------ | Branch (776:16): [True: 0, False: 0] ------------------ 777| 0| { 778| 0| if (type_field (p4->type) == ASN1_ETYPE_CONSTANT) ------------------ | | 215| 0|# define ASN1_ETYPE_CONSTANT 1 ------------------ | Branch (778:10): [True: 0, False: 0] ------------------ 779| 0| { 780| 0| max_constants++; 781| 0| if (max_constants == MAX_CONSTANTS) ------------------ | | 718| 0|#define MAX_CONSTANTS 1024 ------------------ | Branch (781:14): [True: 0, False: 0] ------------------ 782| 0| return ASN1_RECURSION; ------------------ | | 135| 0|# define ASN1_RECURSION 19 ------------------ 783| | 784| 0| p5 = 785| 0| _asn1_add_single_node (ASN1_ETYPE_CONSTANT); ------------------ | | 215| 0|# define ASN1_ETYPE_CONSTANT 1 ------------------ 786| 0| _asn1_set_name (p5, p4->name); 787| 0| if (p4->value) ------------------ | Branch (787:14): [True: 0, False: 0] ------------------ 788| 0| { 789| 0| tlen = _asn1_strlen (p4->value); ------------------ | | 113| 0|# define _asn1_strlen(s) strlen((const char *) s) ------------------ 790| 0| if (tlen > 0) ------------------ | Branch (790:11): [True: 0, False: 0] ------------------ 791| 0| _asn1_set_value (p5, p4->value, tlen + 1); 792| 0| } 793| 0| _asn1_add_static_node2 (list, p5); 794| | 795| 0| if (p2 == p) ------------------ | Branch (795:14): [True: 0, False: 0] ------------------ 796| 0| { 797| 0| _asn1_set_right (p5, p->down); 798| 0| _asn1_set_down (p, p5); 799| 0| } 800| 0| else 801| 0| { 802| 0| _asn1_set_right (p5, p2->right); 803| 0| _asn1_set_right (p2, p5); 804| 0| } 805| 0| p2 = p5; 806| 0| } 807| 0| p4 = p4->right; 808| 0| } 809| 0| move = DOWN; ------------------ | | 131| 0|# define DOWN 3 ------------------ 810| | 811| 0| tries++; 812| 0| if (tries >= EXPAND_OBJECT_ID_MAX_RECURSION) ------------------ | | 76| 0|# define EXPAND_OBJECT_ID_MAX_RECURSION 16 ------------------ | Branch (812:13): [True: 0, False: 0] ------------------ 813| 0| return ASN1_RECURSION; ------------------ | | 135| 0|# define ASN1_RECURSION 19 ------------------ 814| | 815| 0| continue; 816| 0| } 817| 2| } 818| 2| } 819| 1.14k| move = DOWN; ------------------ | | 131| 1.14k|# define DOWN 3 ------------------ 820| 1.14k| } 821| 420| else 822| 420| move = RIGHT; ------------------ | | 130| 420|# define RIGHT 2 ------------------ 823| | 824| 1.56k| tries = 0; 825| 1.56k| if (move == DOWN) ------------------ | | 131| 1.56k|# define DOWN 3 ------------------ | Branch (825:11): [True: 1.14k, False: 420] ------------------ 826| 1.14k| { 827| 1.14k| if (p->down) ------------------ | Branch (827:8): [True: 424, False: 718] ------------------ 828| 424| p = p->down; 829| 718| else 830| 718| move = RIGHT; ------------------ | | 130| 718|# define RIGHT 2 ------------------ 831| 1.14k| } 832| | 833| 1.56k| if (p == node) ------------------ | Branch (833:11): [True: 0, False: 1.56k] ------------------ 834| 0| { 835| 0| move = UP; ------------------ | | 129| 0|# define UP 1 ------------------ 836| 0| continue; 837| 0| } 838| | 839| 1.56k| if (move == RIGHT) ------------------ | | 130| 1.56k|# define RIGHT 2 ------------------ | Branch (839:11): [True: 1.13k, False: 424] ------------------ 840| 1.13k| { 841| 1.13k| if (p && p->right) ------------------ | Branch (841:8): [True: 1.13k, False: 0] | Branch (841:13): [True: 714, False: 424] ------------------ 842| 714| p = p->right; 843| 424| else 844| 424| move = UP; ------------------ | | 129| 424|# define UP 1 ------------------ 845| 1.13k| } 846| 1.56k| if (move == UP) ------------------ | | 129| 1.56k|# define UP 1 ------------------ | Branch (846:11): [True: 424, False: 1.13k] ------------------ 847| 424| p = _asn1_find_up (p); 848| 1.56k| } 849| | 850| | /*******************************/ 851| | /* expand DEFAULT */ 852| | /*******************************/ 853| 4| p = node; 854| 4| move = DOWN; ------------------ | | 131| 4|# define DOWN 3 ------------------ 855| | 856| 1.56k| while (!((p == node) && (move == UP))) ------------------ | | 129| 8|# define UP 1 ------------------ | Branch (856:12): [True: 8, False: 1.55k] | Branch (856:27): [True: 4, False: 4] ------------------ 857| 1.56k| { 858| 1.56k| if (move != UP) ------------------ | | 129| 1.56k|# define UP 1 ------------------ | Branch (858:11): [True: 1.14k, False: 420] ------------------ 859| 1.14k| { 860| 1.14k| if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) && ------------------ | | 226| 1.14k|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (860:8): [True: 68, False: 1.07k] ------------------ 861| 1.14k| (p->type & CONST_DEFAULT)) ------------------ | | 145| 68|# define CONST_DEFAULT (1U<<15) ------------------ | Branch (861:8): [True: 0, False: 68] ------------------ 862| 0| { 863| 0| p2 = p->down; 864| 0| if (p2 && (type_field (p2->type) == ASN1_ETYPE_DEFAULT)) ------------------ | | 223| 0|# define ASN1_ETYPE_DEFAULT 9 ------------------ | Branch (864:12): [True: 0, False: 0] | Branch (864:18): [True: 0, False: 0] ------------------ 865| 0| { 866| 0| _asn1_str_cpy (name2, sizeof (name2), name_root); 867| 0| _asn1_str_cat (name2, sizeof (name2), "."); 868| 0| if (p2->value) ------------------ | Branch (868:9): [True: 0, False: 0] ------------------ 869| 0| _asn1_str_cat (name2, sizeof (name2), (char *) p2->value); 870| 0| p3 = asn1_find_node (node, name2); 871| 0| if (!p3 || (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID) ------------------ | | 226| 0|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (871:9): [True: 0, False: 0] | Branch (871:16): [True: 0, False: 0] ------------------ 872| 0| || !(p3->type & CONST_ASSIGN)) ------------------ | | 166| 0|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (872:12): [True: 0, False: 0] ------------------ 873| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 874| 0| p4 = p3->down; 875| 0| name2[0] = 0; 876| 0| while (p4) ------------------ | Branch (876:12): [True: 0, False: 0] ------------------ 877| 0| { 878| 0| if (type_field (p4->type) == ASN1_ETYPE_CONSTANT) ------------------ | | 215| 0|# define ASN1_ETYPE_CONSTANT 1 ------------------ | Branch (878:13): [True: 0, False: 0] ------------------ 879| 0| { 880| 0| if (p4->value == NULL) ------------------ | Branch (880:10): [True: 0, False: 0] ------------------ 881| 0| return ASN1_VALUE_NOT_FOUND; ------------------ | | 121| 0|# define ASN1_VALUE_NOT_FOUND 5 ------------------ 882| | 883| 0| if (name2[0]) ------------------ | Branch (883:10): [True: 0, False: 0] ------------------ 884| 0| _asn1_str_cat (name2, sizeof (name2), "."); 885| 0| _asn1_str_cat (name2, sizeof (name2), 886| 0| (char *) p4->value); 887| 0| } 888| 0| p4 = p4->right; 889| 0| } 890| 0| tlen = strlen (name2); 891| 0| if (tlen > 0) ------------------ | Branch (891:9): [True: 0, False: 0] ------------------ 892| 0| _asn1_set_value (p2, name2, tlen + 1); 893| 0| } 894| 0| } 895| 1.14k| move = DOWN; ------------------ | | 131| 1.14k|# define DOWN 3 ------------------ 896| 1.14k| } 897| 420| else 898| 420| move = RIGHT; ------------------ | | 130| 420|# define RIGHT 2 ------------------ 899| | 900| 1.56k| if (move == DOWN) ------------------ | | 131| 1.56k|# define DOWN 3 ------------------ | Branch (900:11): [True: 1.14k, False: 420] ------------------ 901| 1.14k| { 902| 1.14k| if (p->down) ------------------ | Branch (902:8): [True: 424, False: 718] ------------------ 903| 424| p = p->down; 904| 718| else 905| 718| move = RIGHT; ------------------ | | 130| 718|# define RIGHT 2 ------------------ 906| 1.14k| } 907| | 908| 1.56k| if (p == node) ------------------ | Branch (908:11): [True: 0, False: 1.56k] ------------------ 909| 0| { 910| 0| move = UP; ------------------ | | 129| 0|# define UP 1 ------------------ 911| 0| continue; 912| 0| } 913| | 914| 1.56k| if (move == RIGHT) ------------------ | | 130| 1.56k|# define RIGHT 2 ------------------ | Branch (914:11): [True: 1.13k, False: 424] ------------------ 915| 1.13k| { 916| 1.13k| if (p && p->right) ------------------ | Branch (916:8): [True: 1.13k, False: 0] | Branch (916:13): [True: 714, False: 424] ------------------ 917| 714| p = p->right; 918| 424| else 919| 424| move = UP; ------------------ | | 129| 424|# define UP 1 ------------------ 920| 1.13k| } 921| 1.56k| if (move == UP) ------------------ | | 129| 1.56k|# define UP 1 ------------------ | Branch (921:11): [True: 424, False: 1.13k] ------------------ 922| 424| p = _asn1_find_up (p); 923| 1.56k| } 924| | 925| 4| return ASN1_SUCCESS; ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ 926| 4|} _asn1_check_identifier: 1014| 4|{ 1015| 4| asn1_node_const p, p2; 1016| 4| char name2[ASN1_MAX_NAME_SIZE * 2 + 2]; 1017| | 1018| 4| if (node == NULL) ------------------ | Branch (1018:7): [True: 0, False: 4] ------------------ 1019| 0| return ASN1_ELEMENT_NOT_FOUND; ------------------ | | 118| 0|# define ASN1_ELEMENT_NOT_FOUND 2 ------------------ 1020| | 1021| 4| p = node; 1022| 1.14k| while (p) ------------------ | Branch (1022:10): [True: 1.14k, False: 4] ------------------ 1023| 1.14k| { 1024| 1.14k| if (p->value && type_field (p->type) == ASN1_ETYPE_IDENTIFIER) ------------------ | | 216| 462|# define ASN1_ETYPE_IDENTIFIER 2 ------------------ | Branch (1024:11): [True: 462, False: 680] | Branch (1024:23): [True: 266, False: 196] ------------------ 1025| 266| { 1026| 266| _asn1_str_cpy (name2, sizeof (name2), node->name); 1027| 266| _asn1_str_cat (name2, sizeof (name2), "."); 1028| 266| _asn1_str_cat (name2, sizeof (name2), (char *) p->value); 1029| 266| p2 = asn1_find_node (node, name2); 1030| 266| if (p2 == NULL) ------------------ | Branch (1030:8): [True: 0, False: 266] ------------------ 1031| 0| { 1032| 0| if (p->value) ------------------ | Branch (1032:12): [True: 0, False: 0] ------------------ 1033| 0| _asn1_str_cpy (_asn1_identifierMissing, 1034| 0| sizeof (_asn1_identifierMissing), 1035| 0| (char *) p->value); 1036| 0| else 1037| 0| _asn1_strcpy (_asn1_identifierMissing, "(null)"); ------------------ | | 117| 0|# define _asn1_strcpy(a,b) strcpy((char *)a, (const char *)b) ------------------ 1038| 0| return ASN1_IDENTIFIER_NOT_FOUND; ------------------ | | 119| 0|# define ASN1_IDENTIFIER_NOT_FOUND 3 ------------------ 1039| 0| } 1040| 266| } 1041| 876| else if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) && ------------------ | | 226| 876|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (1041:16): [True: 68, False: 808] ------------------ 1042| 876| (p->type & CONST_DEFAULT)) ------------------ | | 145| 68|# define CONST_DEFAULT (1U<<15) ------------------ | Branch (1042:9): [True: 0, False: 68] ------------------ 1043| 0| { 1044| 0| p2 = p->down; 1045| 0| if (p2 && (type_field (p2->type) == ASN1_ETYPE_DEFAULT)) ------------------ | | 223| 0|# define ASN1_ETYPE_DEFAULT 9 ------------------ | Branch (1045:8): [True: 0, False: 0] | Branch (1045:14): [True: 0, False: 0] ------------------ 1046| 0| { 1047| 0| _asn1_str_cpy (name2, sizeof (name2), node->name); 1048| 0| if (p2->value) ------------------ | Branch (1048:12): [True: 0, False: 0] ------------------ 1049| 0| { 1050| 0| _asn1_str_cat (name2, sizeof (name2), "."); 1051| 0| _asn1_str_cat (name2, sizeof (name2), (char *) p2->value); 1052| 0| _asn1_str_cpy (_asn1_identifierMissing, 1053| 0| sizeof (_asn1_identifierMissing), 1054| 0| (char *) p2->value); 1055| 0| } 1056| 0| else 1057| 0| _asn1_strcpy (_asn1_identifierMissing, "(null)"); ------------------ | | 117| 0|# define _asn1_strcpy(a,b) strcpy((char *)a, (const char *)b) ------------------ 1058| | 1059| 0| p2 = asn1_find_node (node, name2); 1060| 0| if (!p2 || (type_field (p2->type) != ASN1_ETYPE_OBJECT_ID) || ------------------ | | 226| 0|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (1060:12): [True: 0, False: 0] | Branch (1060:19): [True: 0, False: 0] ------------------ 1061| 0| !(p2->type & CONST_ASSIGN)) ------------------ | | 166| 0|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (1061:5): [True: 0, False: 0] ------------------ 1062| 0| return ASN1_IDENTIFIER_NOT_FOUND; ------------------ | | 119| 0|# define ASN1_IDENTIFIER_NOT_FOUND 3 ------------------ 1063| 0| else 1064| 0| _asn1_identifierMissing[0] = 0; 1065| 0| } 1066| 0| } 1067| 876| else if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) && ------------------ | | 226| 876|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (1067:16): [True: 68, False: 808] ------------------ 1068| 876| (p->type & CONST_ASSIGN)) ------------------ | | 166| 68|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (1068:9): [True: 2, False: 66] ------------------ 1069| 2| { 1070| 2| p2 = p->down; 1071| 2| if (p2 && (type_field (p2->type) == ASN1_ETYPE_CONSTANT)) ------------------ | | 215| 2|# define ASN1_ETYPE_CONSTANT 1 ------------------ | Branch (1071:8): [True: 2, False: 0] | Branch (1071:14): [True: 2, False: 0] ------------------ 1072| 2| { 1073| 2| if (p2->value && !c_isdigit (p2->value[0])) ------------------ | Branch (1073:12): [True: 2, False: 0] | Branch (1073:25): [True: 0, False: 2] ------------------ 1074| 0| { 1075| 0| _asn1_str_cpy (name2, sizeof (name2), node->name); 1076| 0| _asn1_str_cat (name2, sizeof (name2), "."); 1077| 0| _asn1_str_cat (name2, sizeof (name2), (char *) p2->value); 1078| 0| _asn1_str_cpy (_asn1_identifierMissing, 1079| 0| sizeof (_asn1_identifierMissing), 1080| 0| (char *) p2->value); 1081| | 1082| 0| p2 = asn1_find_node (node, name2); 1083| 0| if (!p2 || (type_field (p2->type) != ASN1_ETYPE_OBJECT_ID) ------------------ | | 226| 0|# define ASN1_ETYPE_OBJECT_ID 12 ------------------ | Branch (1083:9): [True: 0, False: 0] | Branch (1083:16): [True: 0, False: 0] ------------------ 1084| 0| || !(p2->type & CONST_ASSIGN)) ------------------ | | 166| 0|# define CONST_ASSIGN (1U<<28) ------------------ | Branch (1084:12): [True: 0, False: 0] ------------------ 1085| 0| return ASN1_IDENTIFIER_NOT_FOUND; ------------------ | | 119| 0|# define ASN1_IDENTIFIER_NOT_FOUND 3 ------------------ 1086| 0| else 1087| 0| _asn1_identifierMissing[0] = 0; 1088| 0| } 1089| 2| } 1090| 2| } 1091| | 1092| 1.14k| if (p->down) ------------------ | Branch (1092:11): [True: 424, False: 718] ------------------ 1093| 424| { 1094| 424| p = p->down; 1095| 424| } 1096| 718| else if (p->right) ------------------ | Branch (1096:16): [True: 392, False: 326] ------------------ 1097| 392| p = p->right; 1098| 326| else 1099| 326| { 1100| 424| while (p) ------------------ | Branch (1100:11): [True: 424, False: 0] ------------------ 1101| 424| { 1102| 424| p = _asn1_find_up (p); 1103| 424| if (p == node) ------------------ | Branch (1103:12): [True: 4, False: 420] ------------------ 1104| 4| { 1105| 4| p = NULL; 1106| 4| break; 1107| 4| } 1108| 420| if (p && p->right) ------------------ | Branch (1108:12): [True: 420, False: 0] | Branch (1108:17): [True: 322, False: 98] ------------------ 1109| 322| { 1110| 322| p = p->right; 1111| 322| break; 1112| 322| } 1113| 420| } 1114| 326| } 1115| 1.14k| } 1116| | 1117| 4| return ASN1_SUCCESS; ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ 1118| 4|} parser_aux.c:_asn1_hash_name: 44| 1.43k|{ 45| 1.43k| const unsigned char *s = (unsigned char *) x; 46| 1.43k| unsigned h = 0; 47| | 48| 17.9k| while (*s) ------------------ | Branch (48:10): [True: 16.5k, False: 1.43k] ------------------ 49| 16.5k| h = (*s++) + ((h << 9) | (h >> (WORD_BIT - 9))); 50| | 51| 1.43k| return h; 52| 1.43k|} structure.c:_asn1_set_down: 112| 424|{ 113| 424| if (node == NULL) ------------------ | Branch (113:7): [True: 0, False: 424] ------------------ 114| 0| return node; 115| 424| node->down = down; 116| 424| if (down) ------------------ | Branch (116:7): [True: 424, False: 0] ------------------ 117| 424| down->left = node; 118| 424| return node; 119| 424|} asn1_array2tree: 179| 4|{ 180| 4| asn1_node p, p_last = NULL; 181| 4| unsigned long k; 182| 4| int move; 183| 4| int result; 184| 4| unsigned int type; 185| 4| list_type *e_list = NULL; 186| | 187| 4| if (errorDescription) ------------------ | Branch (187:7): [True: 0, False: 4] ------------------ 188| 0| errorDescription[0] = 0; 189| | 190| 4| if (*definitions != NULL) ------------------ | Branch (190:7): [True: 0, False: 4] ------------------ 191| 0| return ASN1_ELEMENT_NOT_EMPTY; ------------------ | | 133| 0|# define ASN1_ELEMENT_NOT_EMPTY 17 ------------------ 192| | 193| 4| move = UP; ------------------ | | 129| 4|# define UP 1 ------------------ 194| | 195| 1.14k| for (k = 0; array[k].value || array[k].type || array[k].name; k++) ------------------ | Branch (195:15): [True: 462, False: 684] | Branch (195:33): [True: 680, False: 4] | Branch (195:50): [True: 0, False: 4] ------------------ 196| 1.14k| { 197| 1.14k| type = convert_old_type (array[k].type); 198| | 199| 1.14k| p = _asn1_add_static_node (&e_list, type & (~CONST_DOWN)); ------------------ | | 168| 1.14k|# define CONST_DOWN (1U<<29) ------------------ 200| 1.14k| if (array[k].name) ------------------ | Branch (200:11): [True: 898, False: 244] ------------------ 201| 898| _asn1_set_name (p, array[k].name); 202| 1.14k| if (array[k].value) ------------------ | Branch (202:11): [True: 462, False: 680] ------------------ 203| 462| _asn1_set_value (p, array[k].value, strlen (array[k].value) + 1); 204| | 205| 1.14k| if (*definitions == NULL) ------------------ | Branch (205:11): [True: 4, False: 1.13k] ------------------ 206| 4| *definitions = p; 207| | 208| 1.14k| if (move == DOWN) ------------------ | | 131| 1.14k|# define DOWN 3 ------------------ | Branch (208:11): [True: 424, False: 718] ------------------ 209| 424| { 210| 424| if (p_last && p_last->down) ------------------ | Branch (210:8): [True: 424, False: 0] | Branch (210:18): [True: 0, False: 424] ------------------ 211| 0| _asn1_delete_structure (e_list, &p_last->down, 0); 212| 424| _asn1_set_down (p_last, p); 213| 424| } 214| 718| else if (move == RIGHT) ------------------ | | 130| 718|# define RIGHT 2 ------------------ | Branch (214:16): [True: 714, False: 4] ------------------ 215| 714| { 216| 714| if (p_last && p_last->right) ------------------ | Branch (216:8): [True: 714, False: 0] | Branch (216:18): [True: 0, False: 714] ------------------ 217| 0| _asn1_delete_structure (e_list, &p_last->right, 0); 218| 714| _asn1_set_right (p_last, p); 219| 714| } 220| | 221| 1.14k| p_last = p; 222| | 223| 1.14k| if (type & CONST_DOWN) ------------------ | | 168| 1.14k|# define CONST_DOWN (1U<<29) ------------------ | Branch (223:11): [True: 424, False: 718] ------------------ 224| 424| move = DOWN; ------------------ | | 131| 424|# define DOWN 3 ------------------ 225| 718| else if (type & CONST_RIGHT) ------------------ | | 169| 718|# define CONST_RIGHT (1U<<30) ------------------ | Branch (225:16): [True: 392, False: 326] ------------------ 226| 392| move = RIGHT; ------------------ | | 130| 392|# define RIGHT 2 ------------------ 227| 326| else 228| 326| { 229| 428| while (p_last != *definitions) ------------------ | Branch (229:11): [True: 424, False: 4] ------------------ 230| 424| { 231| 424| p_last = _asn1_find_up (p_last); 232| | 233| 424| if (p_last == NULL) ------------------ | Branch (233:12): [True: 0, False: 424] ------------------ 234| 0| break; 235| | 236| 424| if (p_last->type & CONST_RIGHT) ------------------ | | 169| 424|# define CONST_RIGHT (1U<<30) ------------------ | Branch (236:12): [True: 322, False: 102] ------------------ 237| 322| { 238| 322| p_last->type &= ~CONST_RIGHT; ------------------ | | 169| 322|# define CONST_RIGHT (1U<<30) ------------------ 239| 322| move = RIGHT; ------------------ | | 130| 322|# define RIGHT 2 ------------------ 240| 322| break; 241| 322| } 242| 424| } /* while */ 243| 326| } 244| 1.14k| } /* while */ 245| | 246| 4| if (p_last == *definitions) ------------------ | Branch (246:7): [True: 4, False: 0] ------------------ 247| 4| { 248| 4| result = _asn1_check_identifier (*definitions); 249| 4| if (result == ASN1_SUCCESS) ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ | Branch (249:11): [True: 4, False: 0] ------------------ 250| 4| { 251| 4| _asn1_change_integer_value (*definitions); 252| 4| result = _asn1_expand_object_id (&e_list, *definitions); 253| 4| } 254| 4| } 255| 0| else 256| 0| { 257| 0| result = ASN1_ARRAY_ERROR; ------------------ | | 132| 0|# define ASN1_ARRAY_ERROR 16 ------------------ 258| 0| } 259| | 260| 4| if (errorDescription != NULL) ------------------ | Branch (260:7): [True: 0, False: 4] ------------------ 261| 0| { 262| 0| if (result == ASN1_IDENTIFIER_NOT_FOUND) ------------------ | | 119| 0|# define ASN1_IDENTIFIER_NOT_FOUND 3 ------------------ | Branch (262:11): [True: 0, False: 0] ------------------ 263| 0| { 264| 0| Estrcpy (errorDescription, ":: identifier '"); ------------------ | | 29| 0|# define Estrcpy(x,y) _asn1_str_cpy(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y) | | ------------------ | | | | 315| 0|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128 | | ------------------ ------------------ 265| 0| Estrcat (errorDescription, _asn1_identifierMissing); ------------------ | | 30| 0|# define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y) | | ------------------ | | | | 315| 0|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128 | | ------------------ ------------------ 266| 0| Estrcat (errorDescription, "' not found"); ------------------ | | 30| 0|# define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y) | | ------------------ | | | | 315| 0|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128 | | ------------------ ------------------ 267| 0| } 268| 0| else 269| 0| errorDescription[0] = 0; 270| 0| } 271| | 272| 4| if (result != ASN1_SUCCESS) ------------------ | | 116| 4|# define ASN1_SUCCESS 0 ------------------ | Branch (272:7): [True: 0, False: 4] ------------------ 273| 0| { 274| 0| _asn1_delete_list_and_nodes (e_list); 275| 0| *definitions = NULL; 276| 0| } 277| 4| else 278| 4| _asn1_delete_list (e_list); 279| | 280| 4| return result; 281| 4|} asn1_check_version: 46| 2|{ 47| 2| if (!req_version || strverscmp (req_version, ASN1_VERSION) <= 0) ------------------ | | 71| 2|# define ASN1_VERSION "4.19.0" ------------------ | Branch (47:7): [True: 0, False: 2] | Branch (47:23): [True: 2, False: 0] ------------------ 48| 2| return ASN1_VERSION; ------------------ | | 71| 2|# define ASN1_VERSION "4.19.0" ------------------ 49| | 50| 0| return NULL; 51| 2|} gnutls_crypto_init: 41| 2|{ 42| 2| void *(*defallocfunc)(size_t); 43| 2| void *(*defreallocfunc)(void *, size_t, size_t); 44| 2| void (*deffreefunc)(void *, size_t); 45| | 46| | /* Check if non-default allocators are being used. 47| | * Some applications like guile override GMP allocators 48| | * with GC capable alternatives. Do nothing if this is 49| | * the case. 50| | */ 51| 2| mp_get_memory_functions(&allocfunc, &reallocfunc, &freefunc); 52| 2| mp_set_memory_functions(NULL, NULL, NULL); 53| 2| mp_get_memory_functions(&defallocfunc, &defreallocfunc, &deffreefunc); 54| 2| if (reallocfunc != defreallocfunc || freefunc != deffreefunc) { ------------------ | Branch (54:6): [True: 0, False: 2] | Branch (54:39): [True: 0, False: 2] ------------------ 55| 0| mp_set_memory_functions(allocfunc, reallocfunc, freefunc); 56| 0| return (0); 57| 0| } 58| | 59| | /* Overload GMP allocators with safe alternatives */ 60| 2| mp_set_memory_functions(NULL, gnutls_realloc_zero, gnutls_free_zero); 61| 2| return 0; 62| 2|} _rnd_system_entropy_init: 161| 2|{ 162| 2| int urandom_fd; 163| | 164| 2|#if defined(__linux__) 165| | /* Enable getrandom() usage if available */ 166| 2| if (have_getrandom()) { ------------------ | Branch (166:6): [True: 2, False: 0] ------------------ 167| 2| _rnd_get_system_entropy = _rnd_get_system_entropy_getrandom; 168| 2| _gnutls_debug_log("getrandom random generator was selected\n"); ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 169| 2| return 0; 170| 2| } else { 171| 0| _gnutls_debug_log("getrandom is not available\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 172| 0| } 173| 0|#endif 174| | 175| | /* Fallback: /dev/urandom */ 176| | 177| | /* Check that we can open it */ 178| 0| urandom_fd = open("/dev/urandom", O_RDONLY); 179| 0| if (urandom_fd < 0) { ------------------ | Branch (179:6): [True: 0, False: 0] ------------------ 180| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 181| 0| ("Cannot open /dev/urandom during initialization!\n"); 182| 0| return gnutls_assert_val(GNUTLS_E_RANDOM_DEVICE_ERROR); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 183| 0| } 184| 0| close(urandom_fd); 185| | 186| 0| _rnd_get_system_entropy = _rnd_get_system_entropy_urandom; 187| 0| _gnutls_debug_log("/dev/urandom random generator was selected\n"); ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 188| | 189| 0| return 0; 190| 0|} sysrng-linux.c:have_getrandom: 71| 2|{ 72| 2| char c; 73| 2| int ret; 74| 2| ret = getrandom(&c, 1, 1 /*GRND_NONBLOCK */ ); 75| 2| if (ret == 1 || (ret == -1 && errno == EAGAIN)) ------------------ | Branch (75:6): [True: 2, False: 0] | Branch (75:19): [True: 0, False: 0] | Branch (75:32): [True: 0, False: 0] ------------------ 76| 2| return 1; 77| 0| return 0; 78| 2|} _gnutls_prepare_to_load_system_priorities: 2425| 2|{ 2426| 2| const char *p; 2427| 2| int ret; 2428| | 2429| 2| p = secure_getenv("GNUTLS_SYSTEM_PRIORITY_FILE"); 2430| 2| if (p != NULL) ------------------ | Branch (2430:6): [True: 0, False: 2] ------------------ 2431| 0| system_priority_file = p; 2432| | 2433| 2| p = secure_getenv("GNUTLS_SYSTEM_PRIORITY_FAIL_ON_INVALID"); 2434| 2| if (p != NULL && p[0] == '1' && p[1] == 0) ------------------ | Branch (2434:6): [True: 0, False: 2] | Branch (2434:19): [True: 0, False: 0] | Branch (2434:34): [True: 0, False: 0] ------------------ 2435| 0| fail_on_invalid_config = 1; 2436| | 2437| 2| ret = _gnutls_update_system_priorities(true /* defer_system_wide */ ); 2438| 2| if (ret < 0) { ------------------ | Branch (2438:6): [True: 0, False: 2] ------------------ 2439| 0| _gnutls_debug_log("failed to update system priorities: %s\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2440| 0| gnutls_strerror(ret)); 2441| 0| } 2442| 2|} priority.c:_gnutls_update_system_priorities: 2302| 2|{ 2303| 2| int ret, err = 0; 2304| 2| struct stat sb; 2305| 2| FILE *fp; 2306| 2| gnutls_buffer_st buf; 2307| 2| struct ini_ctx ctx; 2308| | 2309| 2| ret = gnutls_rwlock_rdlock(&system_wide_config_rwlock); ------------------ | | 60| 2| (unlikely(glthread_rwlock_rdlock(RWLOCK)) ? \ | | ------------------ | | | | 73| 6|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 2] | | | | | Branch (73:44): [True: 2, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 61| 2| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 2310| 2| if (ret < 0) { ------------------ | Branch (2310:6): [True: 0, False: 2] ------------------ 2311| 0| return gnutls_assert_val(ret); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 2312| 0| } 2313| | 2314| 2| if (stat(system_priority_file, &sb) < 0) { ------------------ | Branch (2314:6): [True: 2, False: 0] ------------------ 2315| 2| _gnutls_debug_log("cfg: unable to access: %s: %d\n", ------------------ | | 139| 2|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 2|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 2|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | | | 137| 2| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2316| 2| system_priority_file, errno); 2317| 2| goto out; 2318| 2| } 2319| | 2320| 0| if (system_priority_file_loaded && ------------------ | Branch (2320:6): [True: 0, False: 0] ------------------ 2321| 0| system_priority_last_mod == sb.st_mtime) { ------------------ | Branch (2321:6): [True: 0, False: 0] ------------------ 2322| 0| _gnutls_debug_log("cfg: system priority %s has not changed\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2323| 0| system_priority_file); 2324| 0| if (system_wide_config.priority_string) { ------------------ | Branch (2324:7): [True: 0, False: 0] ------------------ 2325| 0| goto out; /* nothing to do */ 2326| 0| } 2327| 0| } 2328| | 2329| 0| (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); ------------------ | | 68| 0| (unlikely(glthread_rwlock_unlock(RWLOCK)) ? \ | | ------------------ | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 69| 0| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 2330| | 2331| 0| ret = gnutls_rwlock_wrlock(&system_wide_config_rwlock); ------------------ | | 64| 0| (unlikely(glthread_rwlock_wrlock(RWLOCK)) ? \ | | ------------------ | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 65| 0| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 2332| 0| if (ret < 0) { ------------------ | Branch (2332:6): [True: 0, False: 0] ------------------ 2333| 0| return gnutls_assert_val(ret); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 2334| 0| } 2335| | 2336| | /* Another thread could have successfully re-read system-wide config, 2337| | * skip re-reading if the mtime it has used is exactly the same. 2338| | */ 2339| 0| if (system_priority_file_loaded) { ------------------ | Branch (2339:6): [True: 0, False: 0] ------------------ 2340| 0| system_priority_file_loaded = 2341| 0| (system_priority_last_mod == sb.st_mtime); 2342| 0| } 2343| | 2344| 0| if (!system_priority_file_loaded) { ------------------ | Branch (2344:6): [True: 0, False: 0] ------------------ 2345| 0| _name_val_array_clear(&system_wide_config.priority_strings); 2346| | 2347| 0| gnutls_free(system_wide_config.priority_string); ------------------ | | 2296| 0|# define gnutls_free(a) gnutls_free((void *) (a)), a=NULL ------------------ 2348| 0| system_wide_config.priority_string = NULL; 2349| | 2350| 0| fp = fopen(system_priority_file, "re"); 2351| 0| if (fp == NULL) { ------------------ | Branch (2351:7): [True: 0, False: 0] ------------------ 2352| 0| _gnutls_debug_log("cfg: unable to open: %s: %d\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2353| 0| system_priority_file, errno); 2354| 0| goto out; 2355| 0| } 2356| | /* Parsing the configuration file needs to be done in 2 phases: 2357| | * first parsing the [global] section 2358| | * and then the other sections, 2359| | * because the [global] section modifies the parsing behavior. 2360| | */ 2361| 0| memset(&ctx, 0, sizeof(ctx)); 2362| 0| err = ini_parse_file(fp, global_ini_handler, &ctx); 2363| 0| if (!err) { ------------------ | Branch (2363:7): [True: 0, False: 0] ------------------ 2364| 0| if (fseek(fp, 0L, SEEK_SET) < 0) { ------------------ | Branch (2364:8): [True: 0, False: 0] ------------------ 2365| 0| _gnutls_debug_log("cfg: unable to rewind: %s\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2366| 0| system_priority_file); 2367| 0| if (fail_on_invalid_config) ------------------ | Branch (2367:9): [True: 0, False: 0] ------------------ 2368| 0| exit(1); 2369| 0| } 2370| 0| err = ini_parse_file(fp, cfg_ini_handler, &ctx); 2371| 0| } 2372| 0| fclose(fp); 2373| 0| if (err) { ------------------ | Branch (2373:7): [True: 0, False: 0] ------------------ 2374| 0| ini_ctx_deinit(&ctx); 2375| 0| _gnutls_debug_log("cfg: unable to parse: %s: %d\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2376| 0| system_priority_file, err); 2377| 0| goto out; 2378| 0| } 2379| 0| cfg_apply(&system_wide_config, &ctx); 2380| 0| ini_ctx_deinit(&ctx); 2381| 0| _gnutls_debug_log("cfg: loaded system config %s mtime %lld\n", ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2382| 0| system_priority_file, 2383| 0| (unsigned long long)sb.st_mtime); 2384| | 2385| 0| } 2386| | 2387| 0| if (system_wide_config.allowlisting) { ------------------ | Branch (2387:6): [True: 0, False: 0] ------------------ 2388| 0| if (defer_system_wide) { ------------------ | Branch (2388:7): [True: 0, False: 0] ------------------ 2389| | /* try constructing a priority string, 2390| | * but don't apply it yet, at this point 2391| | * we're only interested in whether we can */ 2392| 0| ret = construct_system_wide_priority_string(&buf); 2393| 0| _gnutls_buffer_clear(&buf); 2394| 0| _gnutls_debug_log("cfg: deferred setting " ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2395| 0| "system-wide priority string\n"); 2396| 0| } else { 2397| 0| ret = update_system_wide_priority_string(); 2398| 0| _gnutls_debug_log("cfg: finalized " ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2399| 0| "system-wide priority string\n"); 2400| 0| } 2401| 0| if (ret < 0) { ------------------ | Branch (2401:7): [True: 0, False: 0] ------------------ 2402| 0| _gnutls_debug_log ------------------ | | 139| 0|# define _gnutls_debug_log(...) LEVEL(2, __VA_ARGS__) | | ------------------ | | | | 136| 0|# define LEVEL(l, ...) do { if (unlikely(_gnutls_log_level >= l)) \ | | | | ------------------ | | | | | | 73| 0|# define unlikely(x) __builtin_expect((x), 0) | | | | | | ------------------ | | | | | | | Branch (73:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | 137| 0| _gnutls_log( l, __VA_ARGS__); } while(0) | | | | ------------------ | | | | | Branch (137:45): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 2403| 0| ("cfg: unable to build priority string: %s\n", 2404| 0| gnutls_strerror(ret)); 2405| 0| if (fail_on_invalid_config) ------------------ | Branch (2405:8): [True: 0, False: 0] ------------------ 2406| 0| exit(1); 2407| 0| goto out; 2408| 0| } 2409| 0| } 2410| | 2411| 0| system_priority_file_loaded = 1; 2412| 0| system_priority_last_mod = sb.st_mtime; 2413| | 2414| 2| out: 2415| 2| (void)gnutls_rwlock_unlock(&system_wide_config_rwlock); ------------------ | | 68| 2| (unlikely(glthread_rwlock_unlock(RWLOCK)) ? \ | | ------------------ | | | | 73| 6|# define unlikely(x) __builtin_expect((x), 0) | | | | ------------------ | | | | | Branch (73:26): [True: 0, False: 2] | | | | | Branch (73:44): [True: 2, False: 0] | | | | | Branch (73:44): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 69| 2| gnutls_assert_val(GNUTLS_E_LOCKING_ERROR) : 0) | | ------------------ | | | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) | | ------------------ ------------------ 2416| | 2417| 2| if (err && fail_on_invalid_config) { ------------------ | Branch (2417:6): [True: 0, False: 2] | Branch (2417:13): [True: 0, False: 0] ------------------ 2418| 0| exit(1); 2419| 0| } 2420| | 2421| 2| return ret; 2422| 2|} _gnutls_rnd_preinit: 106| 2|{ 107| 2| int ret; 108| | 109| |#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) 110| |# warning Insecure PRNG is enabled 111| | ret = gnutls_crypto_rnd_register(100, &_gnutls_fuzz_rnd_ops); 112| | if (ret < 0) 113| | return ret; 114| | 115| |#elif defined(ENABLE_FIPS140) 116| | /* The FIPS140 random generator is only enabled when we are compiled 117| | * with FIPS support, _and_ the system is in FIPS installed state. 118| | */ 119| | if (_gnutls_fips_mode_enabled()) { 120| | ret = gnutls_crypto_rnd_register(100, &_gnutls_fips_rnd_ops); 121| | if (ret < 0) 122| | return ret; 123| | } 124| |#endif 125| | 126| 2| ret = _rnd_system_entropy_init(); 127| 2| if (ret < 0) ------------------ | Branch (127:6): [True: 0, False: 2] ------------------ 128| 0| return gnutls_assert_val(GNUTLS_E_RANDOM_FAILED); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 129| | 130| 2| ret = glthread_tls_key_init(&ctx_key, delete_ctx); ------------------ | | 135| 2| (pthread_in_use () \ | | ------------------ | | | | 115| 2| (pthread_mutexattr_gettype != NULL || c11_threads_in_use ()) | | | | ------------------ | | | | | | 89| 0|# define c11_threads_in_use() (thrd_exit != NULL) | | | | | | ------------------ | | | | | | | Branch (89:32): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (115:8): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 136| 2| ? pthread_key_create (&(KEY)->key, DESTRUCTOR) \ | | 137| 2| : ((KEY)->singlethread_value = NULL, 0)) ------------------ 131| 2| if (ret) ------------------ | Branch (131:6): [True: 0, False: 2] ------------------ 132| 0| return gnutls_assert_val(GNUTLS_E_RANDOM_FAILED); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 133| | 134| 2| list = 135| 2| gl_list_nx_create_empty(GL_LINKEDHASH_LIST, NULL, NULL, free_ctx, ------------------ | | 28| 2|#define GL_LINKEDHASH_LIST &gl_linkedhash_list_implementation ------------------ 136| 2| false); 137| 2| if (list == NULL) ------------------ | Branch (137:6): [True: 0, False: 2] ------------------ 138| 0| return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR); ------------------ | | 183| 0|# define gnutls_assert_val(x) gnutls_assert_val_int(x, __FILE__, __func__, __LINE__) ------------------ 139| | 140| 2| return 0; 141| 2|} gnutls_system_global_init: 69| 2|{ 70| |#if defined(_WIN32) && defined(NEED_CERT_ENUM_CRLS) 71| | /* used in system/certs.c */ 72| | HMODULE crypto; 73| | crypto = LoadLibrary(TEXT("Crypt32.dll")); 74| | 75| | if (crypto == NULL) 76| | return GNUTLS_E_CRYPTO_INIT_FAILED; 77| | 78| | pCertEnumCRLsInStore = 79| | (CertEnumCRLsInStoreFunc) GetProcAddress(crypto, 80| | "CertEnumCRLsInStore"); 81| | if (pCertEnumCRLsInStore == NULL) { 82| | FreeLibrary(crypto); 83| | return GNUTLS_E_CRYPTO_INIT_FAILED; 84| | } 85| | 86| | Crypt32_dll = crypto; 87| |#endif 88| 2| gnutls_time = time; 89| 2| gnutls_gettime = _gnutls_gettime; 90| 2| return 0; 91| 2|} _gnutls_system_key_init: 70| 2|{ 71| 2| return 0; 72| 2|} psl_free: 1341| 1.86k|{ 1342| 1.86k| if (psl && psl != &builtin_psl) { ------------------ | Branch (1342:6): [True: 1, False: 1.86k] | Branch (1342:13): [True: 0, False: 1] ------------------ 1343| 0| vector_free(&psl->suffixes); 1344| 0| free(psl->dafsa); 1345| 0| free(psl); 1346| 0| } 1347| 1.86k|} psl_builtin: 1366| 1|{ 1367| 1|#ifdef ENABLE_BUILTIN 1368| 1| return &builtin_psl; 1369| |#else 1370| | return NULL; 1371| |#endif 1372| 1|} psl_is_cookie_domain_acceptable: 1640| 3|{ 1641| 3| const char *p; 1642| 3| size_t hostname_length, cookie_domain_length; 1643| | 1644| 3| if (!psl || !hostname || !cookie_domain) ------------------ | Branch (1644:6): [True: 0, False: 3] | Branch (1644:14): [True: 0, False: 3] | Branch (1644:27): [True: 0, False: 3] ------------------ 1645| 0| return 0; 1646| | 1647| 3| while (*cookie_domain == '.') ------------------ | Branch (1647:9): [True: 0, False: 3] ------------------ 1648| 0| cookie_domain++; 1649| | 1650| 3| if (!strcmp(hostname, cookie_domain)) ------------------ | Branch (1650:6): [True: 0, False: 3] ------------------ 1651| 0| return 1; /* an exact match is acceptable (and pretty common) */ 1652| | 1653| 3| if (isip(hostname)) ------------------ | Branch (1653:6): [True: 0, False: 3] ------------------ 1654| 0| return 0; /* Hostname is an IP address and these must match fully (RFC 6265, 5.1.3) */ 1655| | 1656| 3| cookie_domain_length = strlen(cookie_domain); 1657| 3| hostname_length = strlen(hostname); 1658| | 1659| 3| if (cookie_domain_length >= hostname_length) ------------------ | Branch (1659:6): [True: 3, False: 0] ------------------ 1660| 3| return 0; /* cookie_domain is too long */ 1661| | 1662| 0| p = hostname + hostname_length - cookie_domain_length; 1663| 0| if (!strcmp(p, cookie_domain) && p[-1] == '.') { ------------------ | Branch (1663:6): [True: 0, False: 0] | Branch (1663:35): [True: 0, False: 0] ------------------ 1664| | /* OK, cookie_domain matches, but it must be longer than the longest public suffix in 'hostname' */ 1665| | 1666| 0| if (!(p = psl_unregistrable_domain(psl, hostname))) ------------------ | Branch (1666:7): [True: 0, False: 0] ------------------ 1667| 0| return 1; 1668| | 1669| 0| if (cookie_domain_length > strlen(p)) ------------------ | Branch (1669:7): [True: 0, False: 0] ------------------ 1670| 0| return 1; 1671| 0| } 1672| | 1673| 0| return 0; 1674| 0|} psl_str_to_utf8lower: 1717| 6|{ 1718| 6| int ret = PSL_ERR_INVALID_ARG; 1719| | 1720| 6| if (!str) ------------------ | Branch (1720:6): [True: 0, False: 6] ------------------ 1721| 0| return PSL_ERR_INVALID_ARG; 1722| | 1723| | /* shortcut to avoid costly conversion */ 1724| 6| if (str_is_ascii(str)) { ------------------ | Branch (1724:6): [True: 6, False: 0] ------------------ 1725| 6| if (lower) { ------------------ | Branch (1725:7): [True: 6, False: 0] ------------------ 1726| 6| char *p, *tmp; 1727| | 1728| 6| if (!(tmp = strdup(str))) ------------------ | Branch (1728:8): [True: 0, False: 6] ------------------ 1729| 0| return PSL_ERR_NO_MEM; 1730| | 1731| 6| *lower = tmp; 1732| | 1733| | /* convert ASCII string to lowercase */ 1734| 12| for (p = *lower; *p; p++) ------------------ | Branch (1734:21): [True: 6, False: 6] ------------------ 1735| 6| if (isupper(*p)) 1736| 0| *p = tolower(*p); 1737| 6| } 1738| 6| return PSL_SUCCESS; 1739| 6| } 1740| | 1741| |#ifdef WITH_LIBICU 1742| | do { 1743| | size_t str_length = strlen(str); 1744| | UErrorCode status = 0; 1745| | UChar *utf16_dst, *utf16_lower; 1746| | int32_t utf16_dst_length; 1747| | char *utf8_lower; 1748| | UConverter *uconv; 1749| | 1750| | if (str_length < 256) { 1751| | /* C89 allocation */ 1752| | utf16_dst = alloca(sizeof(UChar) * (str_length * 2 + 1)); 1753| | utf16_lower = alloca(sizeof(UChar) * (str_length * 2 + 1)); 1754| | utf8_lower = alloca(str_length * 6 + 1); 1755| | } else { 1756| | utf16_dst = malloc(sizeof(UChar) * (str_length * 2 + 1)); 1757| | utf16_lower = malloc(sizeof(UChar) * (str_length * 2 + 1)); 1758| | utf8_lower = malloc(str_length * 6 + 1); 1759| | 1760| | if (!utf16_dst || !utf16_lower || !utf8_lower) { 1761| | ret = PSL_ERR_NO_MEM; 1762| | goto out; 1763| | } 1764| | } 1765| | 1766| | uconv = ucnv_open(encoding, &status); 1767| | if (U_SUCCESS(status)) { 1768| | utf16_dst_length = ucnv_toUChars(uconv, utf16_dst, str_length * 2 + 1, str, str_length, &status); 1769| | ucnv_close(uconv); 1770| | 1771| | if (U_SUCCESS(status)) { 1772| | int32_t utf16_lower_length = u_strToLower(utf16_lower, str_length * 2 + 1, utf16_dst, utf16_dst_length, locale, &status); 1773| | if (U_SUCCESS(status)) { 1774| | u_strToUTF8(utf8_lower, str_length * 6 + 1, NULL, utf16_lower, utf16_lower_length, &status); 1775| | if (U_SUCCESS(status)) { 1776| | ret = PSL_SUCCESS; 1777| | if (lower) { 1778| | char *tmp = strdup(utf8_lower); 1779| | 1780| | if (tmp) 1781| | *lower = tmp; 1782| | else 1783| | ret = PSL_ERR_NO_MEM; 1784| | } 1785| | } else { 1786| | ret = PSL_ERR_TO_UTF8; 1787| | /* fprintf(stderr, "Failed to convert UTF-16 to UTF-8 (status %d)\n", status); */ 1788| | } 1789| | } else { 1790| | ret = PSL_ERR_TO_LOWER; 1791| | /* fprintf(stderr, "Failed to convert UTF-16 to lowercase (status %d)\n", status); */ 1792| | } 1793| | } else { 1794| | ret = PSL_ERR_TO_UTF16; 1795| | /* fprintf(stderr, "Failed to convert string to UTF-16 (status %d)\n", status); */ 1796| | } 1797| | } else { 1798| | ret = PSL_ERR_CONVERTER; 1799| | /* fprintf(stderr, "Failed to open converter for '%s' (status %d)\n", encoding, status); */ 1800| | } 1801| |out: 1802| | if (str_length >= 256) { 1803| | free(utf16_dst); 1804| | free(utf16_lower); 1805| | free(utf8_lower); 1806| | } 1807| | } while (0); 1808| |#elif defined(WITH_LIBIDN2) || defined(WITH_LIBIDN) 1809| 0| do { 1810| | /* find out local charset encoding */ 1811| 0| if (!encoding) { ------------------ | Branch (1811:7): [True: 0, False: 0] ------------------ 1812| 0|#ifdef HAVE_NL_LANGINFO 1813| 0| encoding = nl_langinfo(CODESET); 1814| |#elif defined _WIN32 1815| | static char buf[16]; 1816| | snprintf(buf, sizeof(buf), "CP%u", GetACP()); 1817| | encoding = buf; 1818| |#endif 1819| 0| if (!encoding || !*encoding) ------------------ | Branch (1819:8): [True: 0, False: 0] | Branch (1819:21): [True: 0, False: 0] ------------------ 1820| 0| encoding = "ASCII"; 1821| 0| } 1822| | 1823| | /* convert to UTF-8 */ 1824| 0| if (strcasecmp(encoding, "utf-8")) { ------------------ | Branch (1824:7): [True: 0, False: 0] ------------------ 1825| 0| iconv_t cd = iconv_open("utf-8", encoding); 1826| | 1827| 0| if (cd != (iconv_t)-1) { ------------------ | Branch (1827:8): [True: 0, False: 0] ------------------ 1828| 0| char *tmp = (char *)str; /* iconv won't change where str points to, but changes tmp itself */ 1829| 0| size_t tmp_len = strlen(str) + 1; 1830| 0| size_t dst_len = tmp_len * 6, dst_len_tmp = dst_len; 1831| 0| char *dst = malloc(dst_len + 1), *dst_tmp = dst; 1832| | 1833| 0| if (!dst) { ------------------ | Branch (1833:9): [True: 0, False: 0] ------------------ 1834| 0| ret = PSL_ERR_NO_MEM; 1835| 0| } 1836| 0| else if (iconv(cd, (WINICONV_CONST char **)&tmp, &tmp_len, &dst_tmp, &dst_len_tmp) != (size_t)-1 ------------------ | Branch (1836:14): [True: 0, False: 0] ------------------ 1837| 0| && iconv(cd, NULL, NULL, &dst_tmp, &dst_len_tmp) != (size_t)-1) ------------------ | Branch (1837:9): [True: 0, False: 0] ------------------ 1838| 0| { 1839| | /* start size for u8_tolower internal memory allocation. 1840| | * u8_tolower() does not terminate the result string. we have 0 byte included in above tmp_len 1841| | * and thus in len. */ 1842| 0| size_t len = dst_len - dst_len_tmp; 1843| | 1844| 0| if ((tmp = (char *)u8_tolower((uint8_t *)dst, len, 0, UNINORM_NFKC, NULL, &len))) { ------------------ | | 133| 0|#define UNINORM_NFKC (&uninorm_nfkc) ------------------ | Branch (1844:10): [True: 0, False: 0] ------------------ 1845| 0| ret = PSL_SUCCESS; 1846| 0| if (lower) { ------------------ | Branch (1846:11): [True: 0, False: 0] ------------------ 1847| 0| *lower = tmp; 1848| 0| tmp = NULL; 1849| 0| } else 1850| 0| free(tmp); 1851| 0| } else { 1852| 0| ret = PSL_ERR_TO_LOWER; 1853| | /* fprintf(stderr, "Failed to convert UTF-8 to lowercase (errno %d)\n", errno); */ 1854| 0| } 1855| 0| } else { 1856| 0| ret = PSL_ERR_TO_UTF8; 1857| | /* fprintf(stderr, "Failed to convert '%s' string into '%s' (%d)\n", src_encoding, dst_encoding, errno); */ 1858| 0| } 1859| | 1860| 0| free(dst); 1861| 0| iconv_close(cd); 1862| 0| } else { 1863| 0| ret = PSL_ERR_TO_UTF8; 1864| | /* fprintf(stderr, "Failed to prepare encoding '%s' into '%s' (%d)\n", src_encoding, dst_encoding, errno); */ 1865| 0| } 1866| 0| } else { 1867| | /* we need a conversion to lowercase */ 1868| 0| uint8_t *tmp; 1869| | 1870| | /* start size for u8_tolower internal memory allocation. 1871| | * u8_tolower() does not terminate the result string, so include terminating 0 byte in len. */ 1872| 0| size_t len = u8_strlen((uint8_t *)str) + 1; 1873| | 1874| 0| if ((tmp = u8_tolower((uint8_t *)str, len, 0, UNINORM_NFKC, NULL, &len))) { ------------------ | | 133| 0|#define UNINORM_NFKC (&uninorm_nfkc) ------------------ | Branch (1874:8): [True: 0, False: 0] ------------------ 1875| 0| ret = PSL_SUCCESS; 1876| 0| if (lower) { ------------------ | Branch (1876:9): [True: 0, False: 0] ------------------ 1877| 0| *lower = (char*)tmp; 1878| 0| tmp = NULL; 1879| 0| } else 1880| 0| free(tmp); 1881| 0| } else { 1882| 0| ret = PSL_ERR_TO_LOWER; 1883| | /* fprintf(stderr, "Failed to convert UTF-8 to lowercase (errno %d)\n", errno); */ 1884| 0| } 1885| 0| } 1886| | 1887| 0| } while (0); ------------------ | Branch (1887:11): [Folded - Ignored] ------------------ 1888| 0|#endif 1889| | 1890| 0| return ret; 1891| 6|} psl_latest: 1935| 1|{ 1936| 1| psl_ctx_t *psl; 1937| 1| const char *psl_fname[3]; 1938| 1| time_t psl_mtime[3]; 1939| 1| int it, ntimes; 1940| | 1941| 1| psl_fname[0] = NULL; /* silence gcc 6.2 false warning */ 1942| | 1943| | /* create array of PSL files reverse sorted by mtime (latest first) */ 1944| 1| ntimes = insert_file(fname, psl_fname, psl_mtime, 0); 1945| 1| ntimes = insert_file(_psl_dist_filename, psl_fname, psl_mtime, ntimes); 1946| 1| ntimes = insert_file(_psl_filename, psl_fname, psl_mtime, ntimes); 1947| | 1948| | /* load PSL data from the latest file, falling back to the second recent, ... */ 1949| 1| for (psl = NULL, it = 0; it < ntimes; it++) { ------------------ | Branch (1949:27): [True: 0, False: 1] ------------------ 1950| 0| if (psl_mtime[it] > _psl_file_time) ------------------ | Branch (1950:7): [True: 0, False: 0] ------------------ 1951| 0| if ((psl = psl_load_file(psl_fname[it]))) ------------------ | Branch (1951:8): [True: 0, False: 0] ------------------ 1952| 0| break; 1953| 0| } 1954| | 1955| | /* if file loading failed or there is no file newer than the builtin data, 1956| | * then return the builtin data. */ 1957| 1| return psl ? psl : (psl_ctx_t *) psl_builtin(); ------------------ | Branch (1957:9): [True: 0, False: 1] ------------------ 1958| 1|} psl.c:isip: 1588| 3|{ 1589| |#ifdef _WIN32 1590| | WCHAR wName[INET6_ADDRSTRLEN+1]; 1591| | 1592| | struct sockaddr_in addr = {0}; 1593| | struct sockaddr_in6 addr6 = {0}; 1594| | 1595| | INT size = sizeof(addr); 1596| | INT size6 = sizeof(addr6); 1597| | 1598| | if (!MultiByteToWideChar(CP_UTF8, 0, hostname, -1, wName, countof(wName))) 1599| | return 0; 1600| | 1601| | return (WSAStringToAddressW(wName, AF_INET, NULL, (struct sockaddr *)&addr, &size) != SOCKET_ERROR) | 1602| | (WSAStringToAddressW(wName, AF_INET6, NULL, (struct sockaddr *)&addr6, &size6) != SOCKET_ERROR); 1603| |#else 1604| 3| struct in_addr addr; 1605| 3| struct in6_addr addr6; 1606| | 1607| 3| return inet_pton(AF_INET, hostname, &addr) || inet_pton(AF_INET6, hostname, &addr6); ------------------ | Branch (1607:9): [True: 0, False: 3] | Branch (1607:48): [True: 0, False: 3] ------------------ 1608| 3|#endif 1609| 3|} psl.c:str_is_ascii: 616| 6|{ 617| 12| while (*s && *((unsigned char *)s) < 128) s++; ------------------ | Branch (617:9): [True: 6, False: 6] | Branch (617:15): [True: 6, False: 0] ------------------ 618| | 619| 6| return !*s; 620| 6|} psl.c:insert_file: 1895| 3|{ 1896| 3| struct stat st; 1897| 3| int it; 1898| | 1899| 3| if (fname && *fname && stat(fname, &st) == 0 && st.st_mtime > _psl_file_time) { ------------------ | Branch (1899:6): [True: 2, False: 1] | Branch (1899:15): [True: 1, False: 1] | Branch (1899:25): [True: 0, False: 1] | Branch (1899:50): [True: 0, False: 0] ------------------ 1900| | /* add file name and mtime to end of array */ 1901| 0| psl_fname[n] = fname; 1902| 0| psl_mtime[n++] = st.st_mtime; 1903| | 1904| | /* move the new entry to it's correct position */ 1905| 0| for (it = n - 2; it >= 0 && st.st_mtime > psl_mtime[it]; it--) { ------------------ | Branch (1905:20): [True: 0, False: 0] | Branch (1905:31): [True: 0, False: 0] ------------------ 1906| 0| psl_fname[it + 1] = psl_fname[it]; 1907| 0| psl_mtime[it + 1] = psl_mtime[it]; 1908| 0| psl_fname[it] = fname; 1909| 0| psl_mtime[it] = st.st_mtime; 1910| 0| } 1911| 0| } 1912| | 1913| 3| return n; 1914| 3|} fat-x86_64.c:fat_init: 177| 2|{ 178| 2| struct x86_features features; 179| 2| int verbose; 180| | 181| | /* FIXME: Replace all getenv calls by getenv_secure? */ 182| 2| verbose = getenv (ENV_VERBOSE) != NULL; ------------------ | | 93| 2|#define ENV_VERBOSE "NETTLE_FAT_VERBOSE" ------------------ 183| 2| if (verbose) ------------------ | Branch (183:7): [True: 0, False: 2] ------------------ 184| 0| fprintf (stderr, "libnettle: fat library initialization.\n"); 185| | 186| 2| get_x86_features (&features); 187| 2| if (verbose) ------------------ | Branch (187:7): [True: 0, False: 2] ------------------ 188| 0| { 189| 0| const char * const vendor_names[3] = 190| 0| { "other", "intel", "amd" }; 191| 0| fprintf (stderr, "libnettle: cpu features: vendor:%s%s%s%s\n", 192| 0| vendor_names[features.vendor], 193| 0| features.have_aesni ? ",aesni" : "", ------------------ | Branch (193:9): [True: 0, False: 0] ------------------ 194| 0| features.have_sha_ni ? ",sha_ni" : "", ------------------ | Branch (194:9): [True: 0, False: 0] ------------------ 195| 0| features.have_pclmul ? ",pclmul" : ""); ------------------ | Branch (195:9): [True: 0, False: 0] ------------------ 196| 0| } 197| 2| if (features.have_aesni) ------------------ | Branch (197:7): [True: 2, False: 0] ------------------ 198| 2| { 199| 2| if (verbose) ------------------ | Branch (199:11): [True: 0, False: 2] ------------------ 200| 0| fprintf (stderr, "libnettle: using aes instructions.\n"); 201| 2| nettle_aes128_encrypt_vec = _nettle_aes128_encrypt_aesni; 202| 2| nettle_aes128_decrypt_vec = _nettle_aes128_decrypt_aesni; 203| 2| nettle_aes192_encrypt_vec = _nettle_aes192_encrypt_aesni; 204| 2| nettle_aes192_decrypt_vec = _nettle_aes192_decrypt_aesni; 205| 2| nettle_aes256_encrypt_vec = _nettle_aes256_encrypt_aesni; 206| 2| nettle_aes256_decrypt_vec = _nettle_aes256_decrypt_aesni; 207| 2| nettle_cbc_aes128_encrypt_vec = _nettle_cbc_aes128_encrypt_aesni; 208| 2| nettle_cbc_aes192_encrypt_vec = _nettle_cbc_aes192_encrypt_aesni; 209| 2| nettle_cbc_aes256_encrypt_vec = _nettle_cbc_aes256_encrypt_aesni; 210| 2| } 211| 0| else 212| 0| { 213| 0| if (verbose) ------------------ | Branch (213:11): [True: 0, False: 0] ------------------ 214| 0| fprintf (stderr, "libnettle: not using aes instructions.\n"); 215| 0| nettle_aes128_encrypt_vec = _nettle_aes128_encrypt_c; 216| 0| nettle_aes128_decrypt_vec = _nettle_aes128_decrypt_c; 217| 0| nettle_aes192_encrypt_vec = _nettle_aes192_encrypt_c; 218| 0| nettle_aes192_decrypt_vec = _nettle_aes192_decrypt_c; 219| 0| nettle_aes256_encrypt_vec = _nettle_aes256_encrypt_c; 220| 0| nettle_aes256_decrypt_vec = _nettle_aes256_decrypt_c; 221| 0| nettle_cbc_aes128_encrypt_vec = _nettle_cbc_aes128_encrypt_c; 222| 0| nettle_cbc_aes192_encrypt_vec = _nettle_cbc_aes192_encrypt_c; 223| 0| nettle_cbc_aes256_encrypt_vec = _nettle_cbc_aes256_encrypt_c; 224| 0| } 225| | 226| 2| if (features.have_sha_ni) ------------------ | Branch (226:7): [True: 2, False: 0] ------------------ 227| 2| { 228| 2| if (verbose) ------------------ | Branch (228:11): [True: 0, False: 2] ------------------ 229| 0| fprintf (stderr, "libnettle: using sha_ni instructions.\n"); 230| 2| nettle_sha1_compress_vec = _nettle_sha1_compress_sha_ni; 231| 2| _nettle_sha256_compress_n_vec = _nettle_sha256_compress_n_sha_ni; 232| 2| } 233| 0| else 234| 0| { 235| 0| if (verbose) ------------------ | Branch (235:11): [True: 0, False: 0] ------------------ 236| 0| fprintf (stderr, "libnettle: not using sha_ni instructions.\n"); 237| 0| nettle_sha1_compress_vec = _nettle_sha1_compress_x86_64; 238| 0| _nettle_sha256_compress_n_vec = _nettle_sha256_compress_n_x86_64; 239| 0| } 240| | 241| 2| if (features.have_pclmul) ------------------ | Branch (241:7): [True: 2, False: 0] ------------------ 242| 2| { 243| 2| if (verbose) ------------------ | Branch (243:11): [True: 0, False: 2] ------------------ 244| 0| fprintf (stderr, "libnettle: using pclmulqdq instructions.\n"); 245| 2| _nettle_ghash_set_key_vec = _nettle_ghash_set_key_pclmul; 246| 2| _nettle_ghash_update_vec = _nettle_ghash_update_pclmul; 247| 2| } 248| 0| else 249| 0| { 250| 0| if (verbose) ------------------ | Branch (250:11): [True: 0, False: 0] ------------------ 251| 0| fprintf (stderr, "libnettle: not using pclmulqdq instructions.\n"); 252| 0| _nettle_ghash_set_key_vec = _nettle_ghash_set_key_c; 253| 0| _nettle_ghash_update_vec = _nettle_ghash_update_table; 254| 0| } 255| | 256| 2| if (features.vendor == X86_INTEL) ------------------ | Branch (256:7): [True: 0, False: 2] ------------------ 257| 0| { 258| 0| if (verbose) ------------------ | Branch (258:11): [True: 0, False: 0] ------------------ 259| 0| fprintf (stderr, "libnettle: intel SSE2 will be used for memxor.\n"); 260| 0| nettle_memxor_vec = _nettle_memxor_sse2; 261| 0| } 262| 2| else 263| 2| { 264| 2| if (verbose) ------------------ | Branch (264:11): [True: 0, False: 2] ------------------ 265| 0| fprintf (stderr, "libnettle: intel SSE2 will not be used for memxor.\n"); 266| 2| nettle_memxor_vec = _nettle_memxor_x86_64; 267| 2| } 268| 2|} fat-x86_64.c:get_x86_features: 68| 2|{ 69| 2| const char *s; 70| 2| features->vendor = X86_OTHER; 71| 2| features->have_aesni = 0; 72| 2| features->have_sha_ni = 0; 73| 2| features->have_pclmul = 0; 74| | 75| 2| s = secure_getenv (ENV_OVERRIDE); ------------------ | | 94| 2|#define ENV_OVERRIDE "NETTLE_FAT_OVERRIDE" ------------------ 76| 2| if (s) ------------------ | Branch (76:7): [True: 0, False: 2] ------------------ 77| 0| for (;;) 78| 0| { 79| 0| const char *sep = strchr (s, ','); 80| 0| size_t length = sep ? (size_t) (sep - s) : strlen(s); ------------------ | Branch (80:18): [True: 0, False: 0] ------------------ 81| | 82| 0| if (SKIP (s, length, "vendor:", 7)) ------------------ | | 61| 0| (((slen) >= (llen) && memcmp ((s), (literal), llen) == 0) \ | | ------------------ | | | Branch (61:3): [True: 0, False: 0] | | | Branch (61:5): [True: 0, False: 0] | | | Branch (61:25): [True: 0, False: 0] | | ------------------ | | 62| 0| ? ((slen) -= (llen), (s) += (llen), 1) : 0) ------------------ 83| 0| { 84| 0| if (MATCH(s, length, "intel", 5)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 85| 0| features->vendor = X86_INTEL; 86| 0| else if (MATCH(s, length, "amd", 3)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 87| 0| features->vendor = X86_AMD; 88| | 89| 0| } 90| 0| else if (MATCH (s, length, "aesni", 5)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 91| 0| features->have_aesni = 1; 92| 0| else if (MATCH (s, length, "sha_ni", 6)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 93| 0| features->have_sha_ni = 1; 94| 0| else if (MATCH (s, length, "pclmul", 6)) ------------------ | | 64| 0| ((slen) == (llen) && memcmp ((s), (literal), llen) == 0) | | ------------------ | | | Branch (64:4): [True: 0, False: 0] | | | Branch (64:24): [True: 0, False: 0] | | ------------------ ------------------ 95| 0| features->have_pclmul = 1; 96| 0| if (!sep) ------------------ | Branch (96:6): [True: 0, False: 0] ------------------ 97| 0| break; 98| 0| s = sep + 1; 99| 0| } 100| 2| else 101| 2| { 102| 2| uint32_t cpuid_data[4]; 103| 2| _nettle_cpuid (0, cpuid_data); 104| 2| if (memcmp (cpuid_data + 1, "Genu" "ntel" "ineI", 12) == 0) ------------------ | Branch (104:11): [True: 0, False: 2] ------------------ 105| 0| features->vendor = X86_INTEL; 106| 2| else if (memcmp (cpuid_data + 1, "Auth" "cAMD" "enti", 12) == 0) ------------------ | Branch (106:16): [True: 2, False: 0] ------------------ 107| 2| features->vendor = X86_AMD; 108| | 109| 2| _nettle_cpuid (1, cpuid_data); 110| 2| if (cpuid_data[2] & 0x2) ------------------ | Branch (110:11): [True: 2, False: 0] ------------------ 111| 2| features->have_pclmul = 1; 112| 2| if (cpuid_data[2] & 0x02000000) ------------------ | Branch (112:11): [True: 2, False: 0] ------------------ 113| 2| features->have_aesni = 1; 114| | 115| 2| _nettle_cpuid (7, cpuid_data); 116| 2| if (cpuid_data[1] & 0x20000000) ------------------ | Branch (116:11): [True: 2, False: 0] ------------------ 117| 2| features->have_sha_ni = 1; 118| 2| } 119| 2|} mp_get_memory_functions: 326| 4|{ 327| 4| if (alloc_func) ------------------ | Branch (327:7): [True: 4, False: 0] ------------------ 328| 4| *alloc_func = gmp_allocate_func; 329| | 330| 4| if (realloc_func) ------------------ | Branch (330:7): [True: 4, False: 0] ------------------ 331| 4| *realloc_func = gmp_reallocate_func; 332| | 333| 4| if (free_func) ------------------ | Branch (333:7): [True: 4, False: 0] ------------------ 334| 4| *free_func = gmp_free_func; 335| 4|} mp_set_memory_functions: 341| 4|{ 342| 4| if (!alloc_func) ------------------ | Branch (342:7): [True: 4, False: 0] ------------------ 343| 4| alloc_func = gmp_default_alloc; 344| 4| if (!realloc_func) ------------------ | Branch (344:7): [True: 2, False: 2] ------------------ 345| 2| realloc_func = gmp_default_realloc; 346| 4| if (!free_func) ------------------ | Branch (346:7): [True: 2, False: 2] ------------------ 347| 2| free_func = gmp_default_free; 348| | 349| 4| gmp_allocate_func = alloc_func; 350| 4| gmp_reallocate_func = realloc_func; 351| 4| gmp_free_func = free_func; 352| 4|} LLVMFuzzerTestOneInput: 68| 1.87k|{ 69| 1.87k| struct cookie_jar *cookie_jar; 70| 1.87k| char *set_cookie; 71| | 72| 1.87k| if (size > 1024) // same as max_len = ... in .options file ------------------ | Branch (72:6): [True: 12, False: 1.86k] ------------------ 73| 12| return 0; 74| | 75| 1.86k| set_cookie = (char *) malloc(size + 1); 76| 1.86k| memcpy(set_cookie, data, size); 77| 1.86k| set_cookie[size] = 0; 78| | 79| 1.86k| CLOSE_STDERR ------------------ | | 30| 1.86k| int bak = dup(STDERR_FILENO); \ | | 31| 1.86k| int fd = open("/dev/null", O_WRONLY); \ | | 32| 1.86k| dup2(fd, STDERR_FILENO); \ | | 33| 1.86k| close(fd); ------------------ 80| | 81| 1.86k| cookie_jar = cookie_jar_new(); 82| 1.86k| cookie_handle_set_cookie(cookie_jar, "x", 81, "p", set_cookie); 83| 1.86k| cookie_handle_set_cookie(cookie_jar, "x", 81, "p", set_cookie); 84| 1.86k| cookie_handle_set_cookie(cookie_jar, "x", 80, "p/d/", set_cookie); 85| 1.86k| cookie_jar_delete(cookie_jar); 86| | 87| 1.86k| RESTORE_STDERR ------------------ | | 36| 1.86k| dup2(bak, STDERR_FILENO); \ | | 37| 1.86k| close(bak); ------------------ 88| | 89| 1.86k| free(set_cookie); 90| | 91| 1.86k| return 0; 92| 1.87k|} c_strncasecmp: 28| 15.1k|{ 29| 15.1k| register const unsigned char *p1 = (const unsigned char *) s1; 30| 15.1k| register const unsigned char *p2 = (const unsigned char *) s2; 31| 15.1k| unsigned char c1, c2; 32| | 33| 15.1k| if (p1 == p2 || n == 0) ------------------ | Branch (33:7): [True: 0, False: 15.1k] | Branch (33:19): [True: 0, False: 15.1k] ------------------ 34| 0| return 0; 35| | 36| 15.1k| do 37| 62.8k| { 38| 62.8k| c1 = c_tolower (*p1); 39| 62.8k| c2 = c_tolower (*p2); 40| | 41| 62.8k| if (--n == 0 || c1 == '\0') ------------------ | Branch (41:11): [True: 9.79k, False: 53.0k] | Branch (41:23): [True: 0, False: 53.0k] ------------------ 42| 9.79k| break; 43| | 44| 53.0k| ++p1; 45| 53.0k| ++p2; 46| 53.0k| } 47| 53.0k| while (c1 == c2); ------------------ | Branch (47:10): [True: 47.7k, False: 5.34k] ------------------ 48| | 49| 15.1k| if (UCHAR_MAX <= INT_MAX) ------------------ | Branch (49:7): [Folded - Ignored] ------------------ 50| 15.1k| return c1 - c2; 51| 0| else 52| | /* On machines where 'char' and 'int' are types of the same size, the 53| | difference of two 'unsigned char' values - including the sign bit - 54| | doesn't fit in an 'int'. */ 55| 0| return _GL_CMP (c1, c2); ------------------ | | 3058| 0|#define _GL_CMP(n1, n2) (((n1) > (n2)) - ((n1) < (n2))) ------------------ 56| 15.1k|} rpl_fflush: 128| 7.21k|{ 129| | /* When stream is NULL, POSIX and C99 only require flushing of "output 130| | streams and update streams in which the most recent operation was not 131| | input", and all implementations do this. 132| | 133| | When stream is "an output stream or an update stream in which the most 134| | recent operation was not input", POSIX and C99 requires that fflush 135| | writes out any buffered data, and all implementations do this. 136| | 137| | When stream is, however, an input stream or an update stream in 138| | which the most recent operation was input, C99 specifies nothing, 139| | and POSIX only specifies behavior if the stream is seekable. 140| | mingw, in particular, drops the input buffer, leaving the file 141| | descriptor positioned at the end of the input buffer. I.e. ftell 142| | (stream) is lost. We don't want to call the implementation's 143| | fflush in this case. 144| | 145| | We test ! freading (stream) here, rather than fwriting (stream), because 146| | what we need to know is whether the stream holds a "read buffer", and on 147| | mingw this is indicated by _IOREAD, regardless of _IOWRT. */ 148| 7.21k| if (stream == NULL || ! freading (stream)) ------------------ | | 40| 7.21k|# define freading(stream) (__freading (stream) != 0) ------------------ | Branch (148:7): [True: 0, False: 7.21k] | Branch (148:25): [True: 7.21k, False: 0] ------------------ 149| 7.21k| return fflush (stream); 150| | 151| 0|#if defined _IO_EOF_SEEN || defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 152| | /* GNU libc, BeOS, Haiku, Linux libc5 */ 153| | 154| 0| clear_ungetc_buffer_preserving_position (stream); 155| | 156| 0| return fflush (stream); 157| | 158| |#else 159| | { 160| | /* What POSIX says: 161| | 1) About the file-position indicator (-> fseeko, ftello): 162| | The file position indicator is incremented by fgetc() and decremented 163| | by ungetc(): 164| | 165| | "... the fgetc() function shall ... advance the associated file 166| | position indicator for the stream ..." 167| | 168| | "The file-position indicator is decremented by each successful 169| | call to ungetc()..." 170| | 2) fflush discards bytes pushed back by ungetc: 171| | 172| | "...any characters pushed back onto the stream by ungetc() 173| | or ungetwc() that have not subsequently been read from the 174| | stream shall be discarded..." 175| | This implies implicitly: fflush does not change the file position 176| | indicator. 177| | 3) Effects on the file descriptor, if the file descriptor is capable of 178| | seeking: 179| | 180| | "...the file offset of the underlying open file description shall 181| | be set to the file position of the stream..." */ 182| | 183| | /* POSIX does not specify fflush behavior for non-seekable input 184| | streams. Some implementations purge unread data, some return 185| | EBADF, some do nothing. */ 186| | off_t pos = ftello (stream); 187| | if (pos == -1) 188| | { 189| | errno = EBADF; 190| | return EOF; 191| | } 192| | 193| | /* Clear the ungetc buffer. */ 194| | clear_ungetc_buffer (stream); 195| | 196| | /* To get here, we must be flushing a seekable input stream, so the 197| | semantics of fpurge are now appropriate to clear the buffer. To 198| | avoid losing data, the lseek is also necessary. */ 199| | { 200| | int result = fpurge (stream); 201| | if (result != 0) 202| | return result; 203| | } 204| | 205| |# if (defined __sferror || defined __DragonFly__ || defined __ANDROID__) && defined __SNPT 206| | /* FreeBSD, NetBSD, OpenBSD, DragonFly, Mac OS X, Cygwin, Minix 3, Android */ 207| | 208| | { 209| | /* Disable seek optimization for the next fseeko call. This tells the 210| | following fseeko call to seek to the desired position directly, rather 211| | than to seek to a block-aligned boundary. */ 212| | int saved_flags = disable_seek_optimization (stream); 213| | int result = fseeko (stream, pos, SEEK_SET); 214| | 215| | restore_seek_optimization (stream, saved_flags); 216| | return result; 217| | } 218| | 219| |# else 220| | 221| | pos = lseek (fileno (stream), pos, SEEK_SET); 222| | if (pos == -1) 223| | return EOF; 224| | /* After a successful lseek, update the file descriptor's position cache 225| | in the stream. */ 226| | update_fpos_cache (stream, pos); 227| | 228| | return 0; 229| | 230| |# endif 231| | } 232| |#endif 233| 7.21k|} rpl_free: 33| 44.7k|{ 34| |# if defined __GNUC__ && !defined __clang__ 35| | /* An invalid GCC optimization 36| | 37| | would optimize away the assignments in the code below, when link-time 38| | optimization (LTO) is enabled. Make the code more complicated, so that 39| | GCC does not grok how to optimize it. */ 40| | int err[2]; 41| | err[0] = errno; 42| | err[1] = errno; 43| | errno = 0; 44| | free (p); 45| | errno = err[errno == 0]; 46| |# else 47| 44.7k| int err = errno; 48| 44.7k| free (p); 49| 44.7k| errno = err; 50| 44.7k|# endif 51| 44.7k|} mktime_internal: 324| 1.56k|{ 325| 1.56k| struct tm tm; 326| | 327| | /* The maximum number of probes (calls to CONVERT) should be enough 328| | to handle any combinations of time zone rule changes, solar time, 329| | leap seconds, and oscillations around a spring-forward gap. 330| | POSIX.1 prohibits leap seconds, but some hosts have them anyway. */ 331| 1.56k| int remaining_probes = 6; 332| | 333| | /* Time requested. Copy it in case CONVERT modifies *TP; this can 334| | occur if TP is localtime's returned value and CONVERT is localtime. */ 335| 1.56k| int sec = tp->tm_sec; 336| 1.56k| int min = tp->tm_min; 337| 1.56k| int hour = tp->tm_hour; 338| 1.56k| int mday = tp->tm_mday; 339| 1.56k| int mon = tp->tm_mon; 340| 1.56k| int year_requested = tp->tm_year; 341| 1.56k| int isdst = tp->tm_isdst; 342| | 343| | /* 1 if the previous probe was DST. */ 344| 1.56k| int dst2 = 0; 345| | 346| | /* Ensure that mon is in range, and set year accordingly. */ 347| 1.56k| int mon_remainder = mon % 12; 348| 1.56k| int negative_mon_remainder = mon_remainder < 0; 349| 1.56k| int mon_years = mon / 12 - negative_mon_remainder; 350| 1.56k| long_int lyear_requested = year_requested; 351| 1.56k| long_int year = lyear_requested + mon_years; 352| | 353| | /* The other values need not be in range: 354| | the remaining code handles overflows correctly. */ 355| | 356| | /* Calculate day of year from year, month, and day of month. 357| | The result need not be in range. */ 358| 1.56k| int mon_yday = ((__mon_yday[leapyear (year)] 359| 1.56k| [mon_remainder + 12 * negative_mon_remainder]) 360| 1.56k| - 1); 361| 1.56k| long_int lmday = mday; 362| 1.56k| long_int yday = mon_yday + lmday; 363| | 364| 1.56k| mktime_offset_t off = *offset; 365| 1.56k| int negative_offset_guess; 366| | 367| 1.56k| int sec_requested = sec; 368| | 369| 1.56k| if (LEAP_SECONDS_POSSIBLE) ------------------ | | 41| 1.56k|# define LEAP_SECONDS_POSSIBLE 1 | | ------------------ | | | Branch (41:32): [Folded - Ignored] | | ------------------ ------------------ 370| 1.56k| { 371| | /* Handle out-of-range seconds specially, 372| | since ydhms_diff assumes every minute has 60 seconds. */ 373| 1.56k| if (sec < 0) ------------------ | Branch (373:11): [True: 0, False: 1.56k] ------------------ 374| 0| sec = 0; 375| 1.56k| if (59 < sec) ------------------ | Branch (375:11): [True: 210, False: 1.35k] ------------------ 376| 210| sec = 59; 377| 1.56k| } 378| | 379| | /* Invert CONVERT by probing. First assume the same offset as last 380| | time. */ 381| | 382| 1.56k| INT_SUBTRACT_WRAPV (0, off, &negative_offset_guess); ------------------ | | 301| 1.56k|#define INT_SUBTRACT_WRAPV(a, b, r) _GL_INT_SUBTRACT_WRAPV (a, b, r) | | ------------------ | | | | 148| 1.56k|# define _GL_INT_SUBTRACT_WRAPV(a, b, r) __builtin_sub_overflow (a, b, r) | | ------------------ ------------------ 383| 1.56k| long_int t0 = ydhms_diff (year, yday, hour, min, sec, 384| 1.56k| EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, ------------------ | | 157| 1.56k|#define EPOCH_YEAR 1970 ------------------ EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, ------------------ | | 158| 1.56k|#define TM_YEAR_BASE 1900 ------------------ 385| 1.56k| negative_offset_guess); 386| 1.56k| long_int t = t0, t1 = t0, t2 = t0; 387| | 388| | /* Repeatedly use the error to improve the guess. */ 389| | 390| 1.56k| while (true) 391| 1.56k| { 392| 1.56k| if (! ranged_convert (convert, &t, &tm)) ------------------ | Branch (392:11): [True: 0, False: 1.56k] ------------------ 393| 0| return -1; 394| 1.56k| long_int dt = tm_diff (year, yday, hour, min, sec, &tm); 395| 1.56k| if (dt == 0) ------------------ | Branch (395:11): [True: 1.56k, False: 0] ------------------ 396| 1.56k| break; 397| | 398| 0| if (t == t1 && t != t2 ------------------ | Branch (398:11): [True: 0, False: 0] | Branch (398:22): [True: 0, False: 0] ------------------ 399| 0| && (tm.tm_isdst < 0 ------------------ | Branch (399:8): [True: 0, False: 0] ------------------ 400| 0| || (isdst < 0 ------------------ | Branch (400:11): [True: 0, False: 0] | Branch (400:12): [True: 0, False: 0] ------------------ 401| 0| ? dst2 <= (tm.tm_isdst != 0) 402| 0| : (isdst != 0) != (tm.tm_isdst != 0)))) 403| | /* We can't possibly find a match, as we are oscillating 404| | between two values. The requested time probably falls 405| | within a spring-forward gap of size DT. Follow the common 406| | practice in this case, which is to return a time that is DT 407| | away from the requested time, preferring a time whose 408| | tm_isdst differs from the requested value. (If no tm_isdst 409| | was requested and only one of the two values has a nonzero 410| | tm_isdst, prefer that value.) In practice, this is more 411| | useful than returning -1. */ 412| 0| goto offset_found; 413| | 414| 0| remaining_probes--; 415| 0| if (remaining_probes == 0) ------------------ | Branch (415:11): [True: 0, False: 0] ------------------ 416| 0| { 417| 0| __set_errno (EOVERFLOW); ------------------ | | 46| 0|# define __set_errno(val) (errno = (val)) ------------------ 418| 0| return -1; 419| 0| } 420| | 421| 0| t1 = t2, t2 = t, t += dt, dst2 = tm.tm_isdst != 0; 422| 0| } 423| | 424| | /* We have a match. Check whether tm.tm_isdst has the requested 425| | value, if any. */ 426| 1.56k| if (isdst_differ (isdst, tm.tm_isdst)) ------------------ | Branch (426:7): [True: 0, False: 1.56k] ------------------ 427| 0| { 428| | /* tm.tm_isdst has the wrong value. Look for a neighboring 429| | time with the right value, and use its UTC offset. 430| | 431| | Heuristic: probe the adjacent timestamps in both directions, 432| | looking for the desired isdst. If none is found within a 433| | reasonable duration bound, assume a one-hour DST difference. 434| | This should work for all real time zone histories in the tz 435| | database. */ 436| | 437| | /* +1 if we wanted standard time but got DST, -1 if the reverse. */ 438| 0| int dst_difference = (isdst == 0) - (tm.tm_isdst == 0); 439| | 440| | /* Distance between probes when looking for a DST boundary. In 441| | tzdata2003a, the shortest period of DST is 601200 seconds 442| | (e.g., America/Recife starting 2000-10-08 01:00), and the 443| | shortest period of non-DST surrounded by DST is 694800 444| | seconds (Africa/Tunis starting 1943-04-17 01:00). Use the 445| | minimum of these two values, so we don't miss these short 446| | periods when probing. */ 447| 0| int stride = 601200; 448| | 449| | /* In TZDB 2021e, the longest period of DST (or of non-DST), in 450| | which the DST (or adjacent DST) difference is not one hour, 451| | is 457243209 seconds: e.g., America/Cambridge_Bay with leap 452| | seconds, starting 1965-10-31 00:00 in a switch from 453| | double-daylight time (-05) to standard time (-07), and 454| | continuing to 1980-04-27 02:00 in a switch from standard time 455| | (-07) to daylight time (-06). */ 456| 0| int duration_max = 457243209; 457| | 458| | /* Search in both directions, so the maximum distance is half 459| | the duration; add the stride to avoid off-by-1 problems. */ 460| 0| int delta_bound = duration_max / 2 + stride; 461| | 462| 0| int delta, direction; 463| | 464| 0| for (delta = stride; delta < delta_bound; delta += stride) ------------------ | Branch (464:28): [True: 0, False: 0] ------------------ 465| 0| for (direction = -1; direction <= 1; direction += 2) ------------------ | Branch (465:23): [True: 0, False: 0] ------------------ 466| 0| { 467| 0| long_int ot; 468| 0| if (! INT_ADD_WRAPV (t, delta * direction, &ot)) ------------------ | | 300| 0|#define INT_ADD_WRAPV(a, b, r) _GL_INT_ADD_WRAPV (a, b, r) | | ------------------ | | | | 147| 0|# define _GL_INT_ADD_WRAPV(a, b, r) __builtin_add_overflow (a, b, r) | | ------------------ ------------------ | Branch (468:10): [True: 0, False: 0] ------------------ 469| 0| { 470| 0| struct tm otm; 471| 0| if (! ranged_convert (convert, &ot, &otm)) ------------------ | Branch (471:7): [True: 0, False: 0] ------------------ 472| 0| return -1; 473| 0| if (! isdst_differ (isdst, otm.tm_isdst)) ------------------ | Branch (473:7): [True: 0, False: 0] ------------------ 474| 0| { 475| | /* We found the desired tm_isdst. 476| | Extrapolate back to the desired time. */ 477| 0| long_int gt = ot + tm_diff (year, yday, hour, min, sec, 478| 0| &otm); 479| 0| if (mktime_min <= gt && gt <= mktime_max) ------------------ | Branch (479:11): [True: 0, False: 0] | Branch (479:31): [True: 0, False: 0] ------------------ 480| 0| { 481| 0| if (convert_time (convert, gt, &tm)) ------------------ | Branch (481:8): [True: 0, False: 0] ------------------ 482| 0| { 483| 0| t = gt; 484| 0| goto offset_found; 485| 0| } 486| 0| if (errno != EOVERFLOW) ------------------ | Branch (486:8): [True: 0, False: 0] ------------------ 487| 0| return -1; 488| 0| } 489| 0| } 490| 0| } 491| 0| } 492| | 493| | /* No unusual DST offset was found nearby. Assume one-hour DST. */ 494| 0| t += 60 * 60 * dst_difference; 495| 0| if (mktime_min <= t && t <= mktime_max && convert_time (convert, t, &tm)) ------------------ | Branch (495:11): [True: 0, False: 0] | Branch (495:30): [True: 0, False: 0] | Branch (495:49): [True: 0, False: 0] ------------------ 496| 0| goto offset_found; 497| | 498| 0| __set_errno (EOVERFLOW); ------------------ | | 46| 0|# define __set_errno(val) (errno = (val)) ------------------ 499| 0| return -1; 500| 0| } 501| | 502| 1.56k| offset_found: 503| | /* Set *OFFSET to the low-order bits of T - T0 - NEGATIVE_OFFSET_GUESS. 504| | This is just a heuristic to speed up the next mktime call, and 505| | correctness is unaffected if integer overflow occurs here. */ 506| 1.56k| INT_SUBTRACT_WRAPV (t, t0, offset); ------------------ | | 301| 1.56k|#define INT_SUBTRACT_WRAPV(a, b, r) _GL_INT_SUBTRACT_WRAPV (a, b, r) | | ------------------ | | | | 148| 1.56k|# define _GL_INT_SUBTRACT_WRAPV(a, b, r) __builtin_sub_overflow (a, b, r) | | ------------------ ------------------ 507| 1.56k| INT_SUBTRACT_WRAPV (*offset, negative_offset_guess, offset); ------------------ | | 301| 1.56k|#define INT_SUBTRACT_WRAPV(a, b, r) _GL_INT_SUBTRACT_WRAPV (a, b, r) | | ------------------ | | | | 148| 1.56k|# define _GL_INT_SUBTRACT_WRAPV(a, b, r) __builtin_sub_overflow (a, b, r) | | ------------------ ------------------ 508| | 509| 1.56k| if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec) ------------------ | | 41| 3.12k|# define LEAP_SECONDS_POSSIBLE 1 | | ------------------ | | | Branch (41:32): [Folded - Ignored] | | ------------------ ------------------ | Branch (509:32): [True: 210, False: 1.35k] ------------------ 510| 210| { 511| | /* Adjust time to reflect the tm_sec requested, not the normalized value. 512| | Also, repair any damage from a false match due to a leap second. */ 513| 210| long_int sec_adjustment = sec == 0 && tm.tm_sec == 60; ------------------ | Branch (513:33): [True: 0, False: 210] | Branch (513:45): [True: 0, False: 0] ------------------ 514| 210| sec_adjustment -= sec; 515| 210| sec_adjustment += sec_requested; 516| 210| if (INT_ADD_WRAPV (t, sec_adjustment, &t) ------------------ | | 300| 210|#define INT_ADD_WRAPV(a, b, r) _GL_INT_ADD_WRAPV (a, b, r) | | ------------------ | | | | 147| 420|# define _GL_INT_ADD_WRAPV(a, b, r) __builtin_add_overflow (a, b, r) | | | | ------------------ | | | | | Branch (147:37): [True: 0, False: 210] | | | | ------------------ | | ------------------ ------------------ 517| 210| || ! (mktime_min <= t && t <= mktime_max)) ------------------ | Branch (517:10): [True: 210, False: 0] | Branch (517:29): [True: 210, False: 0] ------------------ 518| 0| { 519| 0| __set_errno (EOVERFLOW); ------------------ | | 46| 0|# define __set_errno(val) (errno = (val)) ------------------ 520| 0| return -1; 521| 0| } 522| 210| if (! convert_time (convert, t, &tm)) ------------------ | Branch (522:11): [True: 0, False: 210] ------------------ 523| 0| return -1; 524| 210| } 525| | 526| 1.56k| *tp = tm; 527| 1.56k| return t; 528| 1.56k|} mktime.c:leapyear: 164| 1.56k|{ 165| | /* Don't add YEAR to TM_YEAR_BASE, as that might overflow. 166| | Also, work even if YEAR is negative. */ 167| 1.56k| return 168| 1.56k| ((year & 3) == 0 ------------------ | Branch (168:6): [True: 699, False: 864] ------------------ 169| 1.56k| && (year % 100 != 0 ------------------ | Branch (169:10): [True: 384, False: 315] ------------------ 170| 699| || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3))); ------------------ | | 158| 315|#define TM_YEAR_BASE 1900 ------------------ | Branch (170:6): [True: 306, False: 9] ------------------ 171| 1.56k|} mktime.c:ydhms_diff: 207| 3.12k|{ 208| 3.12k| verify (-1 / 2 == 0); ------------------ | | 322| 3.12k|# define verify(R) _GL_VERIFY (R, "verify (" #R ")", -) | | ------------------ | | | | 213| 3.12k|# define _GL_VERIFY(R, DIAGNOSTIC, ...) _Static_assert (R, DIAGNOSTIC) | | ------------------ ------------------ 209| | 210| | /* Compute intervening leap days correctly even if year is negative. 211| | Take care to avoid integer overflow here. */ 212| 3.12k| int a4 = shr (year1, 2) + shr (TM_YEAR_BASE, 2) - ! (year1 & 3); ------------------ | | 158| 3.12k|#define TM_YEAR_BASE 1900 ------------------ 213| 3.12k| int b4 = shr (year0, 2) + shr (TM_YEAR_BASE, 2) - ! (year0 & 3); ------------------ | | 158| 3.12k|#define TM_YEAR_BASE 1900 ------------------ 214| 3.12k| int a100 = (a4 + (a4 < 0)) / 25 - (a4 < 0); 215| 3.12k| int b100 = (b4 + (b4 < 0)) / 25 - (b4 < 0); 216| 3.12k| int a400 = shr (a100, 2); 217| 3.12k| int b400 = shr (b100, 2); 218| 3.12k| int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400); 219| | 220| | /* Compute the desired time without overflowing. */ 221| 3.12k| long_int years = year1 - year0; 222| 3.12k| long_int days = 365 * years + yday1 - yday0 + intervening_leap_days; 223| 3.12k| long_int hours = 24 * days + hour1 - hour0; 224| 3.12k| long_int minutes = 60 * hours + min1 - min0; 225| 3.12k| long_int seconds = 60 * minutes + sec1 - sec0; 226| 3.12k| return seconds; 227| 3.12k|} mktime.c:shr: 140| 18.7k|{ 141| 18.7k| long_int one = 1; 142| 18.7k| return (-one >> 1 == -1 ------------------ | Branch (142:11): [True: 18.7k, False: 0] ------------------ 143| 18.7k| ? a >> b 144| 18.7k| : (a + (a < 0)) / (one << b) - (a < 0)); 145| 18.7k|} mktime.c:ranged_convert: 272| 1.56k|{ 273| 1.56k| long_int t1 = (*t < mktime_min ? mktime_min ------------------ | Branch (273:18): [True: 0, False: 1.56k] ------------------ 274| 1.56k| : *t <= mktime_max ? *t : mktime_max); ------------------ | Branch (274:6): [True: 1.56k, False: 0] ------------------ 275| 1.56k| struct tm *r = convert_time (convert, t1, tp); 276| 1.56k| if (r) ------------------ | Branch (276:7): [True: 1.56k, False: 0] ------------------ 277| 1.56k| { 278| 1.56k| *t = t1; 279| 1.56k| return r; 280| 1.56k| } 281| 0| if (errno != EOVERFLOW) ------------------ | Branch (281:7): [True: 0, False: 0] ------------------ 282| 0| return NULL; 283| | 284| 0| long_int bad = t1; 285| 0| long_int ok = 0; 286| 0| struct tm oktm; oktm.tm_sec = -1; 287| | 288| | /* BAD is a known out-of-range value, and OK is a known in-range one. 289| | Use binary search to narrow the range between BAD and OK until 290| | they differ by 1. */ 291| 0| while (true) 292| 0| { 293| 0| long_int mid = long_int_avg (ok, bad); 294| 0| if (mid == ok || mid == bad) ------------------ | Branch (294:11): [True: 0, False: 0] | Branch (294:24): [True: 0, False: 0] ------------------ 295| 0| break; 296| 0| if (convert_time (convert, mid, tp)) ------------------ | Branch (296:11): [True: 0, False: 0] ------------------ 297| 0| ok = mid, oktm = *tp; 298| 0| else if (errno != EOVERFLOW) ------------------ | Branch (298:16): [True: 0, False: 0] ------------------ 299| 0| return NULL; 300| 0| else 301| 0| bad = mid; 302| 0| } 303| | 304| 0| if (oktm.tm_sec < 0) ------------------ | Branch (304:7): [True: 0, False: 0] ------------------ 305| 0| return NULL; 306| 0| *t = ok; 307| 0| *tp = oktm; 308| 0| return tp; 309| 0|} mktime.c:tm_diff: 247| 1.56k|{ 248| 1.56k| return ydhms_diff (year, yday, hour, min, sec, 249| 1.56k| tp->tm_year, tp->tm_yday, 250| 1.56k| tp->tm_hour, tp->tm_min, tp->tm_sec); 251| 1.56k|} mktime.c:isdst_differ: 190| 1.56k|{ 191| 1.56k| return (!a != !b) && (0 <= a) && (0 <= b); ------------------ | Branch (191:10): [True: 0, False: 1.56k] | Branch (191:24): [True: 0, False: 0] | Branch (191:36): [True: 0, False: 0] ------------------ 192| 1.56k|} mktime.c:convert_time: 259| 1.77k|{ 260| 1.77k| __time64_t x = t; ------------------ | | 46| 1.77k|# define __time64_t time_t ------------------ 261| 1.77k| return convert (&x, tm); 262| 1.77k|} quotearg_n_style: 947| 3.60k|{ 948| 3.60k| struct quoting_options const o = quoting_options_from_style (s); 949| 3.60k| return quotearg_n_options (n, arg, SIZE_MAX, &o); 950| 3.60k|} quotearg_style: 962| 3.60k|{ 963| 3.60k| return quotearg_n_style (0, s, arg); 964| 3.60k|} quotearg.c:quotearg_buffer_restyled: 254| 3.66k|{ 255| 3.66k| size_t i; 256| 3.66k| size_t len = 0; 257| 3.66k| size_t orig_buffersize = 0; 258| 3.66k| char const *quote_string = 0; 259| 3.66k| size_t quote_string_len = 0; 260| 3.66k| bool backslash_escapes = false; 261| 3.66k| bool unibyte_locale = MB_CUR_MAX == 1; 262| 3.66k| bool elide_outer_quotes = (flags & QA_ELIDE_OUTER_QUOTES) != 0; 263| 3.66k| bool pending_shell_escape_end = false; 264| 3.66k| bool encountered_single_quote = false; 265| 3.66k| bool all_c_and_shell_quote_compat = true; 266| | 267| 3.66k|#define STORE(c) \ 268| 3.66k| do \ 269| 3.66k| { \ 270| 3.66k| if (len < buffersize) \ 271| 3.66k| buffer[len] = (c); \ 272| 3.66k| len++; \ 273| 3.66k| } \ 274| 3.66k| while (0) 275| | 276| 3.66k|#define START_ESC() \ 277| 3.66k| do \ 278| 3.66k| { \ 279| 3.66k| if (elide_outer_quotes) \ 280| 3.66k| goto force_outer_quoting_style; \ 281| 3.66k| escaping = true; \ 282| 3.66k| if (quoting_style == shell_always_quoting_style \ 283| 3.66k| && ! pending_shell_escape_end) \ 284| 3.66k| { \ 285| 3.66k| STORE ('\''); \ 286| 3.66k| STORE ('$'); \ 287| 3.66k| STORE ('\''); \ 288| 3.66k| pending_shell_escape_end = true; \ 289| 3.66k| } \ 290| 3.66k| STORE ('\\'); \ 291| 3.66k| } \ 292| 3.66k| while (0) 293| | 294| 3.66k|#define END_ESC() \ 295| 3.66k| do \ 296| 3.66k| { \ 297| 3.66k| if (pending_shell_escape_end && ! escaping) \ 298| 3.66k| { \ 299| 3.66k| STORE ('\''); \ 300| 3.66k| STORE ('\''); \ 301| 3.66k| pending_shell_escape_end = false; \ 302| 3.66k| } \ 303| 3.66k| } \ 304| 3.66k| while (0) 305| | 306| 3.66k| process_input: 307| | 308| 3.66k| switch (quoting_style) 309| 3.66k| { 310| 0| case c_maybe_quoting_style: ------------------ | Branch (310:5): [True: 0, False: 3.66k] ------------------ 311| 0| quoting_style = c_quoting_style; 312| 0| elide_outer_quotes = true; 313| 0| FALLTHROUGH; ------------------ | | 150| 0|#define FALLTHROUGH _GL_ATTRIBUTE_FALLTHROUGH | | ------------------ | | | | 2671| 0|# define _GL_ATTRIBUTE_FALLTHROUGH __attribute__ ((__fallthrough__)) | | ------------------ ------------------ 314| 0| case c_quoting_style: ------------------ | Branch (314:5): [True: 0, False: 3.66k] ------------------ 315| 0| if (!elide_outer_quotes) ------------------ | Branch (315:11): [True: 0, False: 0] ------------------ 316| 0| STORE ('"'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 317| 0| backslash_escapes = true; 318| 0| quote_string = "\""; 319| 0| quote_string_len = 1; 320| 0| break; 321| | 322| 3.66k| case escape_quoting_style: ------------------ | Branch (322:5): [True: 3.66k, False: 0] ------------------ 323| 3.66k| backslash_escapes = true; 324| 3.66k| elide_outer_quotes = false; 325| 3.66k| break; 326| | 327| 0| case locale_quoting_style: ------------------ | Branch (327:5): [True: 0, False: 3.66k] ------------------ 328| 0| case clocale_quoting_style: ------------------ | Branch (328:5): [True: 0, False: 3.66k] ------------------ 329| 0| case custom_quoting_style: ------------------ | Branch (329:5): [True: 0, False: 3.66k] ------------------ 330| 0| { 331| 0| if (quoting_style != custom_quoting_style) ------------------ | Branch (331:13): [True: 0, False: 0] ------------------ 332| 0| { 333| | /* TRANSLATORS: 334| | Get translations for open and closing quotation marks. 335| | The message catalog should translate "`" to a left 336| | quotation mark suitable for the locale, and similarly for 337| | "'". For example, a French Unicode local should translate 338| | these to U+00AB (LEFT-POINTING DOUBLE ANGLE 339| | QUOTATION MARK), and U+00BB (RIGHT-POINTING DOUBLE ANGLE 340| | QUOTATION MARK), respectively. 341| | 342| | If the catalog has no translation, we will try to 343| | use Unicode U+2018 (LEFT SINGLE QUOTATION MARK) and 344| | Unicode U+2019 (RIGHT SINGLE QUOTATION MARK). If the 345| | current locale is not Unicode, locale_quoting_style 346| | will quote 'like this', and clocale_quoting_style will 347| | quote "like this". You should always include translations 348| | for "`" and "'" even if U+2018 and U+2019 are appropriate 349| | for your locale. 350| | 351| | If you don't know what to put here, please see 352| | 353| | and use glyphs suitable for your language. */ 354| 0| left_quote = gettext_quote (N_("`"), quoting_style); ------------------ | | 49| 0|#define N_(msgid) msgid ------------------ 355| 0| right_quote = gettext_quote (N_("'"), quoting_style); ------------------ | | 49| 0|#define N_(msgid) msgid ------------------ 356| 0| } 357| 0| if (!elide_outer_quotes) ------------------ | Branch (357:13): [True: 0, False: 0] ------------------ 358| 0| for (quote_string = left_quote; *quote_string; quote_string++) ------------------ | Branch (358:43): [True: 0, False: 0] ------------------ 359| 0| STORE (*quote_string); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 360| 0| backslash_escapes = true; 361| 0| quote_string = right_quote; 362| 0| quote_string_len = strlen (quote_string); 363| 0| } 364| 0| break; 365| | 366| 0| case shell_escape_quoting_style: ------------------ | Branch (366:5): [True: 0, False: 3.66k] ------------------ 367| 0| backslash_escapes = true; 368| 0| FALLTHROUGH; ------------------ | | 150| 0|#define FALLTHROUGH _GL_ATTRIBUTE_FALLTHROUGH | | ------------------ | | | | 2671| 0|# define _GL_ATTRIBUTE_FALLTHROUGH __attribute__ ((__fallthrough__)) | | ------------------ ------------------ 369| 0| case shell_quoting_style: ------------------ | Branch (369:5): [True: 0, False: 3.66k] ------------------ 370| 0| elide_outer_quotes = true; 371| 0| FALLTHROUGH; ------------------ | | 150| 0|#define FALLTHROUGH _GL_ATTRIBUTE_FALLTHROUGH | | ------------------ | | | | 2671| 0|# define _GL_ATTRIBUTE_FALLTHROUGH __attribute__ ((__fallthrough__)) | | ------------------ ------------------ 372| 0| case shell_escape_always_quoting_style: ------------------ | Branch (372:5): [True: 0, False: 3.66k] ------------------ 373| 0| if (!elide_outer_quotes) ------------------ | Branch (373:11): [True: 0, False: 0] ------------------ 374| 0| backslash_escapes = true; 375| 0| FALLTHROUGH; ------------------ | | 150| 0|#define FALLTHROUGH _GL_ATTRIBUTE_FALLTHROUGH | | ------------------ | | | | 2671| 0|# define _GL_ATTRIBUTE_FALLTHROUGH __attribute__ ((__fallthrough__)) | | ------------------ ------------------ 376| 0| case shell_always_quoting_style: ------------------ | Branch (376:5): [True: 0, False: 3.66k] ------------------ 377| 0| quoting_style = shell_always_quoting_style; 378| 0| if (!elide_outer_quotes) ------------------ | Branch (378:11): [True: 0, False: 0] ------------------ 379| 0| STORE ('\''); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 380| 0| quote_string = "'"; 381| 0| quote_string_len = 1; 382| 0| break; 383| | 384| 0| case literal_quoting_style: ------------------ | Branch (384:5): [True: 0, False: 3.66k] ------------------ 385| 0| elide_outer_quotes = false; 386| 0| break; 387| | 388| 0| default: ------------------ | Branch (388:5): [True: 0, False: 3.66k] ------------------ 389| 0| abort (); 390| 3.66k| } 391| | 392| 217k| for (i = 0; ! (argsize == SIZE_MAX ? arg[i] == '\0' : i == argsize); i++) ------------------ | Branch (392:16): [True: 214k, False: 3.66k] | Branch (392:19): [True: 217k, False: 0] ------------------ 393| 214k| { 394| 214k| unsigned char c; 395| 214k| unsigned char esc; 396| 214k| bool is_right_quote = false; 397| 214k| bool escaping = false; 398| 214k| bool c_and_shell_quote_compat = false; 399| | 400| 214k| if (backslash_escapes ------------------ | Branch (400:11): [True: 214k, False: 0] ------------------ 401| 214k| && quoting_style != shell_always_quoting_style ------------------ | Branch (401:14): [True: 214k, False: 0] ------------------ 402| 214k| && quote_string_len ------------------ | Branch (402:14): [True: 0, False: 214k] ------------------ 403| 214k| && (i + quote_string_len ------------------ | Branch (403:14): [True: 0, False: 0] ------------------ 404| 0| <= (argsize == SIZE_MAX && 1 < quote_string_len ------------------ | Branch (404:19): [True: 0, False: 0] | Branch (404:42): [True: 0, False: 0] ------------------ 405| | /* Use strlen only if we must: when argsize is SIZE_MAX, 406| | and when the quote string is more than 1 byte long. 407| | If we do call strlen, save the result. */ 408| 0| ? (argsize = strlen (arg)) : argsize)) 409| 214k| && memcmp (arg + i, quote_string, quote_string_len) == 0) ------------------ | Branch (409:14): [True: 0, False: 0] ------------------ 410| 0| { 411| 0| if (elide_outer_quotes) ------------------ | Branch (411:15): [True: 0, False: 0] ------------------ 412| 0| goto force_outer_quoting_style; 413| 0| is_right_quote = true; 414| 0| } 415| | 416| 214k| c = arg[i]; 417| 214k| switch (c) 418| 214k| { 419| 0| case '\0': ------------------ | Branch (419:9): [True: 0, False: 214k] ------------------ 420| 0| if (backslash_escapes) ------------------ | Branch (420:15): [True: 0, False: 0] ------------------ 421| 0| { 422| 0| START_ESC (); ------------------ | | 277| 0| do \ | | 278| 0| { \ | | 279| 0| if (elide_outer_quotes) \ | | ------------------ | | | Branch (279:13): [True: 0, False: 0] | | ------------------ | | 280| 0| goto force_outer_quoting_style; \ | | 281| 0| escaping = true; \ | | 282| 0| if (quoting_style == shell_always_quoting_style \ | | ------------------ | | | Branch (282:13): [True: 0, False: 0] | | ------------------ | | 283| 0| && ! pending_shell_escape_end) \ | | ------------------ | | | Branch (283:16): [True: 0, False: 0] | | ------------------ | | 284| 0| { \ | | 285| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 286| 0| STORE ('$'); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 287| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 288| 0| pending_shell_escape_end = true; \ | | 289| 0| } \ | | 290| 0| STORE ('\\'); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 291| 0| } \ | | 292| 0| while (0) | | ------------------ | | | Branch (292:12): [Folded - Ignored] | | ------------------ ------------------ 423| | /* If quote_string were to begin with digits, we'd need to 424| | test for the end of the arg as well. However, it's 425| | hard to imagine any locale that would use digits in 426| | quotes, and set_custom_quoting is documented not to 427| | accept them. Use only a single \0 with shell-escape 428| | as currently digits are not printed within $'...' */ 429| 0| if (quoting_style != shell_always_quoting_style ------------------ | Branch (429:19): [True: 0, False: 0] ------------------ 430| 0| && i + 1 < argsize && '0' <= arg[i + 1] && arg[i + 1] <= '9') ------------------ | Branch (430:22): [True: 0, False: 0] | Branch (430:41): [True: 0, False: 0] | Branch (430:62): [True: 0, False: 0] ------------------ 431| 0| { 432| 0| STORE ('0'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 433| 0| STORE ('0'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 434| 0| } 435| 0| c = '0'; 436| | /* We don't have to worry that this last '0' will be 437| | backslash-escaped because, again, quote_string should 438| | not start with it and because quote_these_too is 439| | documented as not accepting it. */ 440| 0| } 441| 0| else if (flags & QA_ELIDE_NULL_BYTES) ------------------ | Branch (441:20): [True: 0, False: 0] ------------------ 442| 0| continue; 443| 0| break; 444| | 445| 1.00k| case '?': ------------------ | Branch (445:9): [True: 1.00k, False: 213k] ------------------ 446| 1.00k| switch (quoting_style) 447| 1.00k| { 448| 0| case shell_always_quoting_style: ------------------ | Branch (448:13): [True: 0, False: 1.00k] ------------------ 449| 0| if (elide_outer_quotes) ------------------ | Branch (449:19): [True: 0, False: 0] ------------------ 450| 0| goto force_outer_quoting_style; 451| 0| break; 452| | 453| 0| case c_quoting_style: ------------------ | Branch (453:13): [True: 0, False: 1.00k] ------------------ 454| 0| if ((flags & QA_SPLIT_TRIGRAPHS) ------------------ | Branch (454:19): [True: 0, False: 0] ------------------ 455| 0| && i + 2 < argsize && arg[i + 1] == '?') ------------------ | Branch (455:22): [True: 0, False: 0] | Branch (455:41): [True: 0, False: 0] ------------------ 456| 0| switch (arg[i + 2]) 457| 0| { 458| 0| case '!': case '\'': ------------------ | Branch (458:19): [True: 0, False: 0] | Branch (458:29): [True: 0, False: 0] ------------------ 459| 0| case '(': case ')': case '-': case '/': ------------------ | Branch (459:19): [True: 0, False: 0] | Branch (459:29): [True: 0, False: 0] | Branch (459:39): [True: 0, False: 0] | Branch (459:49): [True: 0, False: 0] ------------------ 460| 0| case '<': case '=': case '>': ------------------ | Branch (460:19): [True: 0, False: 0] | Branch (460:29): [True: 0, False: 0] | Branch (460:39): [True: 0, False: 0] ------------------ 461| | /* Escape the second '?' in what would otherwise be 462| | a trigraph. */ 463| 0| if (elide_outer_quotes) ------------------ | Branch (463:25): [True: 0, False: 0] ------------------ 464| 0| goto force_outer_quoting_style; 465| 0| c = arg[i + 2]; 466| 0| i += 2; 467| 0| STORE ('?'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 468| 0| STORE ('"'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 469| 0| STORE ('"'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 470| 0| STORE ('?'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 471| 0| break; 472| | 473| 0| default: ------------------ | Branch (473:19): [True: 0, False: 0] ------------------ 474| 0| break; 475| 0| } 476| 0| break; 477| | 478| 1.00k| default: ------------------ | Branch (478:13): [True: 1.00k, False: 0] ------------------ 479| 1.00k| break; 480| 1.00k| } 481| 1.00k| break; 482| | 483| 1.17k| case '\a': esc = 'a'; goto c_escape; ------------------ | Branch (483:9): [True: 1.17k, False: 213k] ------------------ 484| 997| case '\b': esc = 'b'; goto c_escape; ------------------ | Branch (484:9): [True: 997, False: 213k] ------------------ 485| 1.54k| case '\f': esc = 'f'; goto c_escape; ------------------ | Branch (485:9): [True: 1.54k, False: 212k] ------------------ 486| 1.98k| case '\n': esc = 'n'; goto c_and_shell_escape; ------------------ | Branch (486:9): [True: 1.98k, False: 212k] ------------------ 487| 1.48k| case '\r': esc = 'r'; goto c_and_shell_escape; ------------------ | Branch (487:9): [True: 1.48k, False: 212k] ------------------ 488| 2.57k| case '\t': esc = 't'; goto c_and_shell_escape; ------------------ | Branch (488:9): [True: 2.57k, False: 211k] ------------------ 489| 1.42k| case '\v': esc = 'v'; goto c_escape; ------------------ | Branch (489:9): [True: 1.42k, False: 212k] ------------------ 490| 1.35k| case '\\': esc = c; ------------------ | Branch (490:9): [True: 1.35k, False: 212k] ------------------ 491| | /* Never need to escape '\' in shell case. */ 492| 1.35k| if (quoting_style == shell_always_quoting_style) ------------------ | Branch (492:15): [True: 0, False: 1.35k] ------------------ 493| 0| { 494| 0| if (elide_outer_quotes) ------------------ | Branch (494:19): [True: 0, False: 0] ------------------ 495| 0| goto force_outer_quoting_style; 496| 0| goto store_c; 497| 0| } 498| | 499| | /* No need to escape the escape if we are trying to elide 500| | outer quotes and nothing else is problematic. */ 501| 1.35k| if (backslash_escapes && elide_outer_quotes && quote_string_len) ------------------ | Branch (501:15): [True: 1.35k, False: 0] | Branch (501:36): [True: 0, False: 1.35k] | Branch (501:58): [True: 0, False: 0] ------------------ 502| 0| goto store_c; 503| | 504| 7.38k| c_and_shell_escape: 505| 7.38k| if (quoting_style == shell_always_quoting_style ------------------ | Branch (505:15): [True: 0, False: 7.38k] ------------------ 506| 7.38k| && elide_outer_quotes) ------------------ | Branch (506:18): [True: 0, False: 0] ------------------ 507| 0| goto force_outer_quoting_style; 508| | /* fall through */ 509| 12.5k| c_escape: 510| 12.5k| if (backslash_escapes) ------------------ | Branch (510:15): [True: 12.5k, False: 0] ------------------ 511| 12.5k| { 512| 12.5k| c = esc; 513| 12.5k| goto store_escape; 514| 12.5k| } 515| 0| break; 516| | 517| 1.99k| case '{': case '}': /* sometimes special if isolated */ ------------------ | Branch (517:9): [True: 1.02k, False: 213k] | Branch (517:19): [True: 978, False: 213k] ------------------ 518| 1.99k| if (! (argsize == SIZE_MAX ? arg[1] == '\0' : argsize == 1)) ------------------ | Branch (518:15): [True: 1.98k, False: 9] | Branch (518:18): [True: 1.99k, False: 0] ------------------ 519| 1.98k| break; 520| 1.99k| FALLTHROUGH; ------------------ | | 150| 9|#define FALLTHROUGH _GL_ATTRIBUTE_FALLTHROUGH | | ------------------ | | | | 2671| 9|# define _GL_ATTRIBUTE_FALLTHROUGH __attribute__ ((__fallthrough__)) | | ------------------ ------------------ 521| 4.22k| case '#': case '~': ------------------ | Branch (521:9): [True: 1.91k, False: 212k] | Branch (521:19): [True: 2.30k, False: 211k] ------------------ 522| 4.22k| if (i != 0) ------------------ | Branch (522:15): [True: 4.14k, False: 77] ------------------ 523| 4.14k| break; 524| 4.22k| FALLTHROUGH; ------------------ | | 150| 77|#define FALLTHROUGH _GL_ATTRIBUTE_FALLTHROUGH | | ------------------ | | | | 2671| 77|# define _GL_ATTRIBUTE_FALLTHROUGH __attribute__ ((__fallthrough__)) | | ------------------ ------------------ 525| 1.11k| case ' ': ------------------ | Branch (525:9): [True: 1.03k, False: 213k] ------------------ 526| 1.11k| c_and_shell_quote_compat = true; 527| 1.11k| FALLTHROUGH; ------------------ | | 150| 1.11k|#define FALLTHROUGH _GL_ATTRIBUTE_FALLTHROUGH | | ------------------ | | | | 2671| 1.11k|# define _GL_ATTRIBUTE_FALLTHROUGH __attribute__ ((__fallthrough__)) | | ------------------ ------------------ 528| 2.65k| case '!': /* special in bash */ ------------------ | Branch (528:9): [True: 1.53k, False: 212k] ------------------ 529| 5.79k| case '"': case '$': case '&': ------------------ | Branch (529:9): [True: 1.05k, False: 213k] | Branch (529:19): [True: 1.09k, False: 213k] | Branch (529:29): [True: 991, False: 213k] ------------------ 530| 12.6k| case '(': case ')': case '*': case ';': ------------------ | Branch (530:9): [True: 1.13k, False: 213k] | Branch (530:19): [True: 1.00k, False: 213k] | Branch (530:29): [True: 1.89k, False: 212k] | Branch (530:39): [True: 2.78k, False: 211k] ------------------ 531| 13.5k| case '<': ------------------ | Branch (531:9): [True: 981, False: 213k] ------------------ 532| 16.5k| case '=': /* sometimes special in 0th or (with "set -k") later args */ ------------------ | Branch (532:9): [True: 2.96k, False: 211k] ------------------ 533| 18.8k| case '>': case '[': ------------------ | Branch (533:9): [True: 1.00k, False: 213k] | Branch (533:19): [True: 1.24k, False: 212k] ------------------ 534| 19.8k| case '^': /* special in old /bin/sh, e.g. SunOS 4.1.4 */ ------------------ | Branch (534:9): [True: 1.06k, False: 213k] ------------------ 535| 21.8k| case '`': case '|': ------------------ | Branch (535:9): [True: 972, False: 213k] | Branch (535:19): [True: 978, False: 213k] ------------------ 536| | /* A shell special character. In theory, '$' and '`' could 537| | be the first bytes of multibyte characters, which means 538| | we should check them with mbrtowc, but in practice this 539| | doesn't happen so it's not worth worrying about. */ 540| 21.8k| if (quoting_style == shell_always_quoting_style ------------------ | Branch (540:15): [True: 0, False: 21.8k] ------------------ 541| 21.8k| && elide_outer_quotes) ------------------ | Branch (541:18): [True: 0, False: 0] ------------------ 542| 0| goto force_outer_quoting_style; 543| 21.8k| break; 544| | 545| 21.8k| case '\'': ------------------ | Branch (545:9): [True: 1.03k, False: 213k] ------------------ 546| 1.03k| encountered_single_quote = true; 547| 1.03k| c_and_shell_quote_compat = true; 548| 1.03k| if (quoting_style == shell_always_quoting_style) ------------------ | Branch (548:15): [True: 0, False: 1.03k] ------------------ 549| 0| { 550| 0| if (elide_outer_quotes) ------------------ | Branch (550:19): [True: 0, False: 0] ------------------ 551| 0| goto force_outer_quoting_style; 552| | 553| 0| if (buffersize && ! orig_buffersize) ------------------ | Branch (553:19): [True: 0, False: 0] | Branch (553:33): [True: 0, False: 0] ------------------ 554| 0| { 555| | /* Just scan string to see if supports a more concise 556| | representation, rather than writing a longer string 557| | but returning the length of the more concise form. */ 558| 0| orig_buffersize = buffersize; 559| 0| buffersize = 0; 560| 0| } 561| | 562| 0| STORE ('\''); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 563| 0| STORE ('\\'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 564| 0| STORE ('\''); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 565| 0| pending_shell_escape_end = false; 566| 0| } 567| 1.03k| break; 568| | 569| 7.74k| case '%': case '+': case ',': case '-': case '.': case '/': ------------------ | Branch (569:9): [True: 1.75k, False: 212k] | Branch (569:19): [True: 1.24k, False: 212k] | Branch (569:29): [True: 1.03k, False: 213k] | Branch (569:39): [True: 1.41k, False: 212k] | Branch (569:49): [True: 1.00k, False: 213k] | Branch (569:59): [True: 1.29k, False: 212k] ------------------ 570| 16.9k| case '0': case '1': case '2': case '3': case '4': case '5': ------------------ | Branch (570:9): [True: 2.83k, False: 211k] | Branch (570:19): [True: 1.16k, False: 213k] | Branch (570:29): [True: 1.27k, False: 212k] | Branch (570:39): [True: 1.19k, False: 213k] | Branch (570:49): [True: 1.17k, False: 213k] | Branch (570:59): [True: 1.55k, False: 212k] ------------------ 571| 23.0k| case '6': case '7': case '8': case '9': case ':': ------------------ | Branch (571:9): [True: 1.14k, False: 213k] | Branch (571:19): [True: 1.24k, False: 212k] | Branch (571:29): [True: 1.23k, False: 212k] | Branch (571:39): [True: 1.16k, False: 213k] | Branch (571:49): [True: 1.34k, False: 212k] ------------------ 572| 29.5k| case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': ------------------ | Branch (572:9): [True: 1.16k, False: 213k] | Branch (572:19): [True: 994, False: 213k] | Branch (572:29): [True: 985, False: 213k] | Branch (572:39): [True: 1.23k, False: 212k] | Branch (572:49): [True: 1.12k, False: 213k] | Branch (572:59): [True: 1.00k, False: 213k] ------------------ 573| 35.7k| case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': ------------------ | Branch (573:9): [True: 1.02k, False: 213k] | Branch (573:19): [True: 996, False: 213k] | Branch (573:29): [True: 1.16k, False: 213k] | Branch (573:39): [True: 990, False: 213k] | Branch (573:49): [True: 978, False: 213k] | Branch (573:59): [True: 987, False: 213k] ------------------ 574| 42.6k| case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': ------------------ | Branch (574:9): [True: 1.70k, False: 212k] | Branch (574:19): [True: 1.12k, False: 213k] | Branch (574:29): [True: 996, False: 213k] | Branch (574:39): [True: 1.12k, False: 213k] | Branch (574:49): [True: 981, False: 213k] | Branch (574:59): [True: 987, False: 213k] ------------------ 575| 49.3k| case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': ------------------ | Branch (575:9): [True: 1.14k, False: 213k] | Branch (575:19): [True: 1.34k, False: 212k] | Branch (575:29): [True: 991, False: 213k] | Branch (575:39): [True: 1.01k, False: 213k] | Branch (575:49): [True: 978, False: 213k] | Branch (575:59): [True: 1.19k, False: 213k] ------------------ 576| 56.0k| case 'Y': case 'Z': case ']': case '_': case 'a': case 'b': ------------------ | Branch (576:9): [True: 978, False: 213k] | Branch (576:19): [True: 993, False: 213k] | Branch (576:29): [True: 1.24k, False: 212k] | Branch (576:39): [True: 981, False: 213k] | Branch (576:49): [True: 1.54k, False: 212k] | Branch (576:59): [True: 994, False: 213k] ------------------ 577| 63.5k| case 'c': case 'd': case 'e': case 'f': case 'g': case 'h': ------------------ | Branch (577:9): [True: 1.07k, False: 213k] | Branch (577:19): [True: 1.10k, False: 213k] | Branch (577:29): [True: 1.92k, False: 212k] | Branch (577:39): [True: 1.15k, False: 213k] | Branch (577:49): [True: 1.21k, False: 213k] | Branch (577:59): [True: 1.07k, False: 213k] ------------------ 578| 71.6k| case 'i': case 'j': case 'k': case 'l': case 'm': case 'n': ------------------ | Branch (578:9): [True: 1.15k, False: 213k] | Branch (578:19): [True: 1.71k, False: 212k] | Branch (578:29): [True: 975, False: 213k] | Branch (578:39): [True: 1.19k, False: 213k] | Branch (578:49): [True: 1.85k, False: 212k] | Branch (578:59): [True: 1.16k, False: 213k] ------------------ 579| 79.5k| case 'o': case 'p': case 'q': case 'r': case 's': case 't': ------------------ | Branch (579:9): [True: 1.31k, False: 212k] | Branch (579:19): [True: 1.29k, False: 212k] | Branch (579:29): [True: 1.05k, False: 213k] | Branch (579:39): [True: 1.44k, False: 212k] | Branch (579:49): [True: 1.70k, False: 212k] | Branch (579:59): [True: 1.13k, False: 213k] ------------------ 580| 86.7k| case 'u': case 'v': case 'w': case 'x': case 'y': case 'z': ------------------ | Branch (580:9): [True: 1.08k, False: 213k] | Branch (580:19): [True: 975, False: 213k] | Branch (580:29): [True: 1.32k, False: 212k] | Branch (580:39): [True: 1.67k, False: 212k] | Branch (580:49): [True: 1.05k, False: 213k] | Branch (580:59): [True: 1.04k, False: 213k] ------------------ 581| | /* These characters don't cause problems, no matter what the 582| | quoting style is. They cannot start multibyte sequences. 583| | A digit or a special letter would cause trouble if it 584| | appeared at the beginning of quote_string because we'd then 585| | escape by prepending a backslash. However, it's hard to 586| | imagine any locale that would use digits or letters as 587| | quotes, and set_custom_quoting is documented not to accept 588| | them. Also, a digit or a special letter would cause 589| | trouble if it appeared in quote_these_too, but that's also 590| | documented as not accepting them. */ 591| 86.7k| c_and_shell_quote_compat = true; 592| 86.7k| break; 593| | 594| 84.9k| default: ------------------ | Branch (594:9): [True: 84.9k, False: 129k] ------------------ 595| | /* If we have a multibyte sequence, copy it until we reach 596| | its end, find an error, or come back to the initial shift 597| | state. For C-like styles, if the sequence has 598| | unprintable characters, escape the whole sequence, since 599| | we can't easily escape single characters within it. */ 600| 84.9k| { 601| | /* Length of multibyte sequence found so far. */ 602| 84.9k| size_t m; 603| | 604| 84.9k| bool printable; 605| | 606| 84.9k| if (unibyte_locale) ------------------ | Branch (606:17): [True: 84.9k, False: 0] ------------------ 607| 84.9k| { 608| 84.9k| m = 1; 609| 84.9k| printable = isprint (c) != 0; 610| 84.9k| } 611| 0| else 612| 0| { 613| 0| mbstate_t mbstate; 614| 0| memset (&mbstate, 0, sizeof mbstate); 615| | 616| 0| m = 0; 617| 0| printable = true; 618| 0| if (argsize == SIZE_MAX) ------------------ | Branch (618:21): [True: 0, False: 0] ------------------ 619| 0| argsize = strlen (arg); 620| | 621| 0| do 622| 0| { 623| 0| wchar_t w; 624| 0| size_t bytes = mbrtowc (&w, &arg[i + m], 625| 0| argsize - (i + m), &mbstate); 626| 0| if (bytes == 0) ------------------ | Branch (626:25): [True: 0, False: 0] ------------------ 627| 0| break; 628| 0| else if (bytes == (size_t) -1) ------------------ | Branch (628:30): [True: 0, False: 0] ------------------ 629| 0| { 630| 0| printable = false; 631| 0| break; 632| 0| } 633| 0| else if (bytes == (size_t) -2) ------------------ | Branch (633:30): [True: 0, False: 0] ------------------ 634| 0| { 635| 0| printable = false; 636| 0| while (i + m < argsize && arg[i + m]) ------------------ | Branch (636:32): [True: 0, False: 0] | Branch (636:51): [True: 0, False: 0] ------------------ 637| 0| m++; 638| 0| break; 639| 0| } 640| 0| else 641| 0| { 642| | /* Work around a bug with older shells that "see" a '\' 643| | that is really the 2nd byte of a multibyte character. 644| | In practice the problem is limited to ASCII 645| | chars >= '@' that are shell special chars. */ 646| 0| if ('[' == 0x5b && elide_outer_quotes ------------------ | Branch (646:29): [Folded - Ignored] | Branch (646:44): [True: 0, False: 0] ------------------ 647| 0| && quoting_style == shell_always_quoting_style) ------------------ | Branch (647:32): [True: 0, False: 0] ------------------ 648| 0| { 649| 0| size_t j; 650| 0| for (j = 1; j < bytes; j++) ------------------ | Branch (650:41): [True: 0, False: 0] ------------------ 651| 0| switch (arg[i + m + j]) 652| 0| { 653| 0| case '[': case '\\': case '^': ------------------ | Branch (653:33): [True: 0, False: 0] | Branch (653:43): [True: 0, False: 0] | Branch (653:54): [True: 0, False: 0] ------------------ 654| 0| case '`': case '|': ------------------ | Branch (654:33): [True: 0, False: 0] | Branch (654:43): [True: 0, False: 0] ------------------ 655| 0| goto force_outer_quoting_style; 656| | 657| 0| default: ------------------ | Branch (657:33): [True: 0, False: 0] ------------------ 658| 0| break; 659| 0| } 660| 0| } 661| | 662| 0| if (! iswprint (w)) ------------------ | Branch (662:29): [True: 0, False: 0] ------------------ 663| 0| printable = false; 664| 0| m += bytes; 665| 0| } 666| 0| } 667| 0| while (! mbsinit (&mbstate)); ------------------ | Branch (667:24): [True: 0, False: 0] ------------------ 668| 0| } 669| | 670| 84.9k| c_and_shell_quote_compat = printable; 671| | 672| 84.9k| if (1 < m || (backslash_escapes && ! printable)) ------------------ | Branch (672:17): [True: 0, False: 84.9k] | Branch (672:27): [True: 84.9k, False: 0] | Branch (672:48): [True: 83.9k, False: 987] ------------------ 673| 83.9k| { 674| | /* Output a multibyte sequence, or an escaped 675| | unprintable unibyte character. */ 676| 83.9k| size_t ilim = i + m; 677| | 678| 83.9k| for (;;) 679| 83.9k| { 680| 83.9k| if (backslash_escapes && ! printable) ------------------ | Branch (680:25): [True: 83.9k, False: 0] | Branch (680:46): [True: 83.9k, False: 0] ------------------ 681| 83.9k| { 682| 83.9k| START_ESC (); ------------------ | | 277| 83.9k| do \ | | 278| 83.9k| { \ | | 279| 83.9k| if (elide_outer_quotes) \ | | ------------------ | | | Branch (279:13): [True: 0, False: 83.9k] | | ------------------ | | 280| 83.9k| goto force_outer_quoting_style; \ | | 281| 83.9k| escaping = true; \ | | 282| 83.9k| if (quoting_style == shell_always_quoting_style \ | | ------------------ | | | Branch (282:13): [True: 0, False: 83.9k] | | ------------------ | | 283| 83.9k| && ! pending_shell_escape_end) \ | | ------------------ | | | Branch (283:16): [True: 0, False: 0] | | ------------------ | | 284| 83.9k| { \ | | 285| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 286| 0| STORE ('$'); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 287| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 288| 0| pending_shell_escape_end = true; \ | | 289| 0| } \ | | 290| 83.9k| STORE ('\\'); \ | | ------------------ | | | | 268| 83.9k| do \ | | | | 269| 83.9k| { \ | | | | 270| 83.9k| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 83.0k, False: 889] | | | | ------------------ | | | | 271| 83.9k| buffer[len] = (c); \ | | | | 272| 83.9k| len++; \ | | | | 273| 83.9k| } \ | | | | 274| 83.9k| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 291| 83.9k| } \ | | 292| 83.9k| while (0) | | ------------------ | | | Branch (292:12): [Folded - Ignored] | | ------------------ ------------------ 683| 83.9k| STORE ('0' + (c >> 6)); ------------------ | | 268| 83.9k| do \ | | 269| 83.9k| { \ | | 270| 83.9k| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 83.0k, False: 907] | | ------------------ | | 271| 83.9k| buffer[len] = (c); \ | | 272| 83.9k| len++; \ | | 273| 83.9k| } \ | | 274| 83.9k| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 684| 83.9k| STORE ('0' + ((c >> 3) & 7)); ------------------ | | 268| 83.9k| do \ | | 269| 83.9k| { \ | | 270| 83.9k| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 83.0k, False: 914] | | ------------------ | | 271| 83.9k| buffer[len] = (c); \ | | 272| 83.9k| len++; \ | | 273| 83.9k| } \ | | 274| 83.9k| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 685| 83.9k| c = '0' + (c & 7); 686| 83.9k| } 687| 0| else if (is_right_quote) ------------------ | Branch (687:30): [True: 0, False: 0] ------------------ 688| 0| { 689| 0| STORE ('\\'); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 690| 0| is_right_quote = false; 691| 0| } 692| 83.9k| if (ilim <= i + 1) ------------------ | Branch (692:25): [True: 83.9k, False: 0] ------------------ 693| 83.9k| break; 694| 0| END_ESC (); ------------------ | | 295| 0| do \ | | 296| 0| { \ | | 297| 0| if (pending_shell_escape_end && ! escaping) \ | | ------------------ | | | Branch (297:13): [True: 0, False: 0] | | | Branch (297:41): [True: 0, False: 0] | | ------------------ | | 298| 0| { \ | | 299| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 300| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 301| 0| pending_shell_escape_end = false; \ | | 302| 0| } \ | | 303| 0| } \ | | 304| 0| while (0) | | ------------------ | | | Branch (304:12): [Folded - Ignored] | | ------------------ ------------------ 695| 0| STORE (c); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 696| 0| c = arg[++i]; 697| 0| } 698| | 699| 83.9k| goto store_c; 700| 83.9k| } 701| 84.9k| } 702| 214k| } 703| | 704| 117k| if (! (((backslash_escapes && quoting_style != shell_always_quoting_style) ------------------ | Branch (704:16): [True: 117k, False: 0] | Branch (704:37): [True: 117k, False: 0] ------------------ 705| 117k| || elide_outer_quotes) ------------------ | Branch (705:18): [True: 0, False: 0] ------------------ 706| 117k| && quote_these_too ------------------ | Branch (706:17): [True: 117k, False: 0] ------------------ 707| 117k| && quote_these_too[c / INT_BITS] >> (c % INT_BITS) & 1) ------------------ | | 55| 117k|#define INT_BITS (sizeof (int) * CHAR_BIT) ------------------ && quote_these_too[c / INT_BITS] >> (c % INT_BITS) & 1) ------------------ | | 55| 117k|#define INT_BITS (sizeof (int) * CHAR_BIT) ------------------ | Branch (707:17): [True: 0, False: 117k] ------------------ 708| 117k| && !is_right_quote) ------------------ | Branch (708:14): [True: 117k, False: 0] ------------------ 709| 117k| goto store_c; 710| | 711| 12.5k| store_escape: 712| 12.5k| START_ESC (); ------------------ | | 277| 12.5k| do \ | | 278| 12.5k| { \ | | 279| 12.5k| if (elide_outer_quotes) \ | | ------------------ | | | Branch (279:13): [True: 0, False: 12.5k] | | ------------------ | | 280| 12.5k| goto force_outer_quoting_style; \ | | 281| 12.5k| escaping = true; \ | | 282| 12.5k| if (quoting_style == shell_always_quoting_style \ | | ------------------ | | | Branch (282:13): [True: 0, False: 12.5k] | | ------------------ | | 283| 12.5k| && ! pending_shell_escape_end) \ | | ------------------ | | | Branch (283:16): [True: 0, False: 0] | | ------------------ | | 284| 12.5k| { \ | | 285| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 286| 0| STORE ('$'); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 287| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 288| 0| pending_shell_escape_end = true; \ | | 289| 0| } \ | | 290| 12.5k| STORE ('\\'); \ | | ------------------ | | | | 268| 12.5k| do \ | | | | 269| 12.5k| { \ | | | | 270| 12.5k| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 12.4k, False: 51] | | | | ------------------ | | | | 271| 12.5k| buffer[len] = (c); \ | | | | 272| 12.5k| len++; \ | | | | 273| 12.5k| } \ | | | | 274| 12.5k| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 291| 12.5k| } \ | | 292| 12.5k| while (0) | | ------------------ | | | Branch (292:12): [Folded - Ignored] | | ------------------ ------------------ 713| | 714| 214k| store_c: 715| 214k| END_ESC (); ------------------ | | 295| 214k| do \ | | 296| 214k| { \ | | 297| 214k| if (pending_shell_escape_end && ! escaping) \ | | ------------------ | | | Branch (297:13): [True: 0, False: 214k] | | | Branch (297:41): [True: 0, False: 0] | | ------------------ | | 298| 214k| { \ | | 299| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 300| 0| STORE ('\''); \ | | ------------------ | | | | 268| 0| do \ | | | | 269| 0| { \ | | | | 270| 0| if (len < buffersize) \ | | | | ------------------ | | | | | Branch (270:13): [True: 0, False: 0] | | | | ------------------ | | | | 271| 0| buffer[len] = (c); \ | | | | 272| 0| len++; \ | | | | 273| 0| } \ | | | | 274| 0| while (0) | | | | ------------------ | | | | | Branch (274:12): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 301| 0| pending_shell_escape_end = false; \ | | 302| 0| } \ | | 303| 214k| } \ | | 304| 214k| while (0) | | ------------------ | | | Branch (304:12): [Folded - Ignored] | | ------------------ ------------------ 716| 214k| STORE (c); ------------------ | | 268| 214k| do \ | | 269| 214k| { \ | | 270| 214k| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 213k, False: 1.02k] | | ------------------ | | 271| 214k| buffer[len] = (c); \ | | 272| 214k| len++; \ | | 273| 214k| } \ | | 274| 214k| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 717| | 718| 214k| if (! c_and_shell_quote_compat) ------------------ | Branch (718:11): [True: 124k, False: 89.8k] ------------------ 719| 124k| all_c_and_shell_quote_compat = false; 720| 214k| } 721| | 722| 3.66k| if (len == 0 && quoting_style == shell_always_quoting_style ------------------ | Branch (722:7): [True: 24, False: 3.63k] | Branch (722:19): [True: 0, False: 24] ------------------ 723| 3.66k| && elide_outer_quotes) ------------------ | Branch (723:10): [True: 0, False: 0] ------------------ 724| 0| goto force_outer_quoting_style; 725| | 726| | /* Single shell quotes (') are commonly enough used as an apostrophe, 727| | that we attempt to minimize the quoting in this case. Note itʼs 728| | better to use the apostrophe modifier "\u02BC" if possible, as that 729| | renders better and works with the word match regex \W+ etc. */ 730| 3.66k| if (quoting_style == shell_always_quoting_style && ! elide_outer_quotes ------------------ | Branch (730:7): [True: 0, False: 3.66k] | Branch (730:54): [True: 0, False: 0] ------------------ 731| 3.66k| && encountered_single_quote) ------------------ | Branch (731:10): [True: 0, False: 0] ------------------ 732| 0| { 733| 0| if (all_c_and_shell_quote_compat) ------------------ | Branch (733:11): [True: 0, False: 0] ------------------ 734| 0| return quotearg_buffer_restyled (buffer, orig_buffersize, arg, argsize, 735| 0| c_quoting_style, 736| 0| flags, quote_these_too, 737| 0| left_quote, right_quote); 738| 0| else if (! buffersize && orig_buffersize) ------------------ | Branch (738:16): [True: 0, False: 0] | Branch (738:32): [True: 0, False: 0] ------------------ 739| 0| { 740| | /* Disable read-only scan, and reprocess to write quoted string. */ 741| 0| buffersize = orig_buffersize; 742| 0| len = 0; 743| 0| goto process_input; 744| 0| } 745| 0| } 746| | 747| 3.66k| if (quote_string && !elide_outer_quotes) ------------------ | Branch (747:7): [True: 0, False: 3.66k] | Branch (747:23): [True: 0, False: 0] ------------------ 748| 0| for (; *quote_string; quote_string++) ------------------ | Branch (748:12): [True: 0, False: 0] ------------------ 749| 0| STORE (*quote_string); ------------------ | | 268| 0| do \ | | 269| 0| { \ | | 270| 0| if (len < buffersize) \ | | ------------------ | | | Branch (270:13): [True: 0, False: 0] | | ------------------ | | 271| 0| buffer[len] = (c); \ | | 272| 0| len++; \ | | 273| 0| } \ | | 274| 0| while (0) | | ------------------ | | | Branch (274:12): [Folded - Ignored] | | ------------------ ------------------ 750| | 751| 3.66k| if (len < buffersize) ------------------ | Branch (751:7): [True: 3.60k, False: 51] ------------------ 752| 3.60k| buffer[len] = '\0'; 753| 3.66k| return len; 754| | 755| 0| force_outer_quoting_style: 756| | /* Don't reuse quote_these_too, since the addition of outer quotes 757| | sufficiently quotes the specified characters. */ 758| 0| if (quoting_style == shell_always_quoting_style && backslash_escapes) ------------------ | Branch (758:7): [True: 0, False: 0] | Branch (758:54): [True: 0, False: 0] ------------------ 759| 0| quoting_style = shell_escape_always_quoting_style; 760| 0| return quotearg_buffer_restyled (buffer, buffersize, arg, argsize, 761| 0| quoting_style, 762| 0| flags & ~QA_ELIDE_OUTER_QUOTES, NULL, 763| 0| left_quote, right_quote); 764| 3.66k|} quotearg.c:quotearg_n_options: 871| 3.60k|{ 872| 3.60k| int e = errno; 873| | 874| 3.60k| struct slotvec *sv = slotvec; 875| | 876| 3.60k| int nslots_max = MIN (INT_MAX, IDX_MAX); 877| 3.60k| if (! (0 <= n && n < nslots_max)) ------------------ | Branch (877:10): [True: 3.60k, False: 0] | Branch (877:20): [True: 3.60k, False: 0] ------------------ 878| 0| abort (); 879| | 880| 3.60k| if (nslots <= n) ------------------ | Branch (880:7): [True: 0, False: 3.60k] ------------------ 881| 0| { 882| 0| bool preallocated = (sv == &slotvec0); 883| 0| idx_t new_nslots = nslots; 884| | 885| 0| slotvec = sv = xpalloc (preallocated ? NULL : sv, &new_nslots, ------------------ | Branch (885:31): [True: 0, False: 0] ------------------ 886| 0| n - nslots + 1, nslots_max, sizeof *sv); 887| 0| if (preallocated) ------------------ | Branch (887:11): [True: 0, False: 0] ------------------ 888| 0| *sv = slotvec0; 889| 0| memset (sv + nslots, 0, (new_nslots - nslots) * sizeof *sv); 890| 0| nslots = new_nslots; 891| 0| } 892| | 893| 3.60k| { 894| 3.60k| size_t size = sv[n].size; 895| 3.60k| char *val = sv[n].val; 896| | /* Elide embedded null bytes since we don't return a size. */ 897| 3.60k| int flags = options->flags | QA_ELIDE_NULL_BYTES; 898| 3.60k| size_t qsize = quotearg_buffer_restyled (val, size, arg, argsize, 899| 3.60k| options->style, flags, 900| 3.60k| options->quote_these_too, 901| 3.60k| options->left_quote, 902| 3.60k| options->right_quote); 903| | 904| 3.60k| if (size <= qsize) ------------------ | Branch (904:9): [True: 51, False: 3.55k] ------------------ 905| 51| { 906| 51| sv[n].size = size = qsize + 1; 907| 51| if (val != slot0) ------------------ | Branch (907:13): [True: 50, False: 1] ------------------ 908| 50| free (val); 909| 51| sv[n].val = val = xcharalloc (size); 910| 51| quotearg_buffer_restyled (val, size, arg, argsize, options->style, 911| 51| flags, options->quote_these_too, 912| 51| options->left_quote, 913| 51| options->right_quote); 914| 51| } 915| | 916| 3.60k| errno = e; 917| 3.60k| return val; 918| 3.60k| } 919| 3.60k|} quotearg.c:quoting_options_from_style: 186| 3.60k|{ 187| 3.60k| struct quoting_options o = { literal_quoting_style, 0, { 0 }, NULL, NULL }; 188| 3.60k| if (style == custom_quoting_style) ------------------ | Branch (188:7): [True: 0, False: 3.60k] ------------------ 189| 0| abort (); 190| 3.60k| o.style = style; 191| 3.60k| return o; 192| 3.60k|} rpl_timegm: 31| 1.56k|{ 32| 1.56k| static mktime_offset_t gmtime_offset; 33| 1.56k| tmp->tm_isdst = 0; 34| 1.56k| return __mktime_internal (tmp, __gmtime64_r, &gmtime_offset); ------------------ | | 69| 1.56k|# define __mktime_internal mktime_internal ------------------ return __mktime_internal (tmp, __gmtime64_r, &gmtime_offset); ------------------ | | 47| 1.56k|# define __gmtime64_r __gmtime_r | | ------------------ | | | | 66| 1.56k|# define __gmtime_r gmtime_r | | ------------------ ------------------ 35| 1.56k|} xmalloc: 44| 18.9k|{ 45| 18.9k| return nonnull (malloc (s)); 46| 18.9k|} xcharalloc: 56| 51|{ 57| 51| return XNMALLOC (n, char); ------------------ | | 115| 51| ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t)))) | | ------------------ | | | Branch (115:13): [Folded - Ignored] | | ------------------ ------------------ 58| 51|} xrealloc: 65| 1.03k|{ 66| 1.03k| void *r = realloc (p, s); 67| 1.03k| if (!r && (!p || s)) ------------------ | Branch (67:7): [True: 0, False: 1.03k] | Branch (67:14): [True: 0, False: 0] | Branch (67:20): [True: 0, False: 0] ------------------ 68| 0| xalloc_die (); 69| 1.03k| return r; 70| 1.03k|} xcalloc: 297| 5.60k|{ 298| 5.60k| return nonnull (calloc (n, s)); 299| 5.60k|} xmemdup: 313| 2.65k|{ 314| 2.65k| return memcpy (xmalloc (s), p, s); 315| 2.65k|} xstrdup: 338| 2.65k|{ 339| 2.65k| return xmemdup (string, strlen (string) + 1); 340| 2.65k|} xmalloc.c:nonnull: 34| 24.5k|{ 35| 24.5k| if (!p) ------------------ | Branch (35:7): [True: 0, False: 24.5k] ------------------ 36| 0| xalloc_die (); 37| 24.5k| return p; 38| 24.5k|} c_isdigit: 232| 520|{ 233| 520| switch (c) 234| 520| { 235| 94| _C_CTYPE_DIGIT: ------------------ | | 133| 28| case '0': case '1': case '2': case '3': \ | | ------------------ | | | Branch (133:4): [True: 3, False: 517] | | | Branch (133:14): [True: 4, False: 516] | | | Branch (133:24): [True: 21, False: 499] | | | Branch (133:34): [True: 0, False: 520] | | ------------------ | | 134| 91| case '4': case '5': case '6': case '7': \ | | ------------------ | | | Branch (134:4): [True: 9, False: 511] | | | Branch (134:14): [True: 3, False: 517] | | | Branch (134:24): [True: 3, False: 517] | | | Branch (134:34): [True: 48, False: 472] | | ------------------ | | 135| 94| case '8': case '9' | | ------------------ | | | Branch (135:4): [True: 0, False: 520] | | ------------------ ------------------ 236| 94| return true; 237| 426| default: ------------------ | Branch (237:5): [True: 426, False: 94] ------------------ 238| 426| return false; 239| 520| } 240| 520|} c_isspace: 299| 386k|{ 300| 386k| switch (c) 301| 386k| { 302| 15.5k| case ' ': case '\t': case '\n': case '\v': case '\f': case '\r': ------------------ | Branch (302:5): [True: 4.30k, False: 381k] | Branch (302:15): [True: 2.32k, False: 383k] | Branch (302:26): [True: 3.59k, False: 382k] | Branch (302:37): [True: 1.99k, False: 384k] | Branch (302:48): [True: 1.50k, False: 384k] | Branch (302:59): [True: 1.86k, False: 384k] ------------------ 303| 15.5k| return true; 304| 370k| default: ------------------ | Branch (304:5): [True: 370k, False: 15.5k] ------------------ 305| 370k| return false; 306| 386k| } 307| 386k|} c_tolower: 336| 129k|{ 337| 129k| switch (c) 338| 129k| { 339| 5.49k| _C_CTYPE_UPPER: ------------------ | | 146| 0|#define _C_CTYPE_UPPER _C_CTYPE_LOWER_N ('A' - 'a') | | ------------------ | | | | 120| 2.00k| _C_CTYPE_LOWER_A_THRU_F_N(N): \ | | | | ------------------ | | | | | | 117| 975| case 'a' + (N): case 'b' + (N): case 'c' + (N): case 'd' + (N): \ | | | | | | ------------------ | | | | | | | Branch (117:4): [True: 153, False: 129k] | | | | | | | Branch (117:20): [True: 3, False: 129k] | | | | | | | Branch (117:36): [True: 6, False: 129k] | | | | | | | Branch (117:52): [True: 813, False: 129k] | | | | | | ------------------ | | | | | | 118| 2.00k| case 'e' + (N): case 'f' + (N) | | | | | | ------------------ | | | | | | | Branch (118:4): [True: 1.02k, False: 128k] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (120:4): [True: 3, False: 129k] | | | | ------------------ | | | | 121| 2.83k| case 'g' + (N): case 'h' + (N): case 'i' + (N): case 'j' + (N): \ | | | | ------------------ | | | | | Branch (121:4): [True: 0, False: 129k] | | | | | Branch (121:20): [True: 6, False: 129k] | | | | | Branch (121:36): [True: 831, False: 129k] | | | | | Branch (121:52): [True: 0, False: 129k] | | | | ------------------ | | | | 122| 2.99k| case 'k' + (N): case 'l' + (N): case 'm' + (N): case 'n' + (N): \ | | | | ------------------ | | | | | Branch (122:4): [True: 0, False: 129k] | | | | | Branch (122:20): [True: 9, False: 129k] | | | | | Branch (122:36): [True: 147, False: 129k] | | | | | Branch (122:52): [True: 0, False: 129k] | | | | ------------------ | | | | 123| 4.41k| case 'o' + (N): case 'p' + (N): case 'q' + (N): case 'r' + (N): \ | | | | ------------------ | | | | | Branch (123:4): [True: 483, False: 129k] | | | | | Branch (123:20): [True: 573, False: 129k] | | | | | Branch (123:36): [True: 6, False: 129k] | | | | | Branch (123:52): [True: 360, False: 129k] | | | | ------------------ | | | | 124| 5.24k| case 's' + (N): case 't' + (N): case 'u' + (N): case 'v' + (N): \ | | | | ------------------ | | | | | Branch (124:4): [True: 804, False: 129k] | | | | | Branch (124:20): [True: 12, False: 129k] | | | | | Branch (124:36): [True: 3, False: 129k] | | | | | Branch (124:52): [True: 9, False: 129k] | | | | ------------------ | | | | 125| 5.49k| case 'w' + (N): case 'x' + (N): case 'y' + (N): case 'z' + (N) | | | | ------------------ | | | | | Branch (125:4): [True: 15, False: 129k] | | | | | Branch (125:20): [True: 213, False: 129k] | | | | | Branch (125:36): [True: 9, False: 129k] | | | | ------------------ | | ------------------ ------------------ 340| 5.49k| return c - 'A' + 'a'; 341| 124k| default: ------------------ | Branch (341:5): [True: 124k, False: 5.49k] ------------------ 342| 124k| return c; 343| 129k| } 344| 129k|} cookie_jar_new: 92| 1.86k|{ 93| 1.86k| struct cookie_jar *jar = xnew (struct cookie_jar); ------------------ | | 49| 1.86k|#define xnew(type) (xmalloc (sizeof (type))) ------------------ 94| 1.86k| jar->chains = make_nocase_string_hash_table (0); 95| 1.86k| jar->cookie_count = 0; 96| 1.86k| return jar; 97| 1.86k|} cookie_handle_set_cookie: 740| 5.60k|{ 741| 5.60k| struct cookie *cookie; 742| 5.60k| cookies_now = time (NULL); 743| 5.60k| char buf[1024], *tmp; 744| 5.60k| size_t pathlen = strlen(path); 745| | 746| | /* Wget's paths don't begin with '/' (blame rfc1808), but cookie 747| | usage assumes /-prefixed paths. Until the rest of Wget is fixed, 748| | simply prepend slash to PATH. */ 749| 5.60k| if (pathlen < sizeof (buf) - 1) ------------------ | Branch (749:7): [True: 5.60k, False: 0] ------------------ 750| 5.60k| tmp = buf; 751| 0| else 752| 0| tmp = xmalloc (pathlen + 2); 753| | 754| 5.60k| *tmp = '/'; 755| 5.60k| memcpy (tmp + 1, path, pathlen + 1); 756| 5.60k| path = tmp; 757| | 758| 5.60k| cookie = parse_set_cookie (set_cookie, false); 759| 5.60k| if (!cookie) ------------------ | Branch (759:7): [True: 3.25k, False: 2.34k] ------------------ 760| 3.25k| goto out; 761| | 762| | /* Sanitize parts of cookie. */ 763| | 764| 2.34k| if (!cookie->domain) ------------------ | Branch (764:7): [True: 2.13k, False: 207] ------------------ 765| 2.13k| { 766| 2.13k| cookie->domain = xstrdup (host); 767| 2.13k| cookie->domain_exact = 1; 768| | /* Set the port, but only if it's non-default. */ 769| 2.13k| if (port != 80 && port != 443) ------------------ | Branch (769:11): [True: 1.42k, False: 713] | Branch (769:25): [True: 1.42k, False: 0] ------------------ 770| 1.42k| cookie->port = port; 771| 2.13k| } 772| 207| else 773| 207| { 774| 207| if (!check_domain_match (cookie->domain, host)) ------------------ | Branch (774:11): [True: 177, False: 30] ------------------ 775| 177| { 776| 177| logprintf (LOG_NOTQUIET, 777| 177| _("Cookie coming from %s attempted to set domain to "), ------------------ | | 64| 177|#define _(STRING) gettext(STRING) ------------------ 778| 177| quotearg_style (escape_quoting_style, host)); 779| 177| logprintf (LOG_NOTQUIET, 780| 177| _("%s\n"), ------------------ | | 64| 177|#define _(STRING) gettext(STRING) ------------------ 781| 177| quotearg_style (escape_quoting_style, cookie->domain)); 782| 177| cookie->discard_requested = true; 783| 177| } 784| 207| } 785| | 786| 2.34k| if (!cookie->path) ------------------ | Branch (786:7): [True: 2.15k, False: 195] ------------------ 787| 2.15k| { 788| | /* The cookie doesn't set path: set it to the URL path, sans the 789| | file part ("/dir/file" truncated to "/dir/"). */ 790| 2.15k| char *trailing_slash = strrchr (path, '/'); 791| 2.15k| if (trailing_slash) ------------------ | Branch (791:11): [True: 2.15k, False: 0] ------------------ 792| 2.15k| cookie->path = strdupdelim (path, trailing_slash + 1); 793| 0| else 794| | /* no slash in the string -- can this even happen? */ 795| 0| cookie->path = xstrdup (path); 796| 2.15k| } 797| 195| else 798| 195| { 799| | /* The cookie sets its own path; verify that it is legal. */ 800| 195| if (!check_path_match (cookie->path, path)) ------------------ | Branch (800:11): [True: 162, False: 33] ------------------ 801| 162| { 802| 162| DEBUGP (("Attempt to fake the path: %s, %s\n", ------------------ | | 129| 162|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 162|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 162|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 162] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 803| 162| cookie->path, path)); 804| 162| goto out; 805| 162| } 806| 195| } 807| | 808| | /* Now store the cookie, or discard an existing cookie, if 809| | discarding was requested. */ 810| | 811| 2.18k| if (cookie->discard_requested) ------------------ | Branch (811:7): [True: 631, False: 1.55k] ------------------ 812| 631| { 813| 631| discard_matching_cookie (jar, cookie); 814| 631| goto out; 815| 631| } 816| | 817| 1.55k| store_cookie (jar, cookie); 818| 1.55k| if (tmp != buf) ------------------ | Branch (818:7): [True: 0, False: 1.55k] ------------------ 819| 0| xfree (tmp); ------------------ | | 54| 0|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 820| 1.55k| return; 821| | 822| 4.04k| out: 823| 4.04k| if (cookie) ------------------ | Branch (823:7): [True: 793, False: 3.25k] ------------------ 824| 793| delete_cookie (cookie); 825| 4.04k| if (tmp != buf) ------------------ | Branch (825:7): [True: 0, False: 4.04k] ------------------ 826| 0| xfree (tmp); ------------------ | | 54| 0|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 827| 4.04k|} cookie_jar_delete: 1430| 1.86k|{ 1431| | /* Iterate over chains (indexed by domain) and free them. */ 1432| 1.86k| hash_table_iterator iter; 1433| 2.38k| for (hash_table_iterate (jar->chains, &iter); hash_table_iter_next (&iter); ) ------------------ | Branch (1433:49): [True: 519, False: 1.86k] ------------------ 1434| 519| { 1435| 519| struct cookie *chain = iter.value; 1436| 519| xfree (iter.key); ------------------ | | 54| 519|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 1437| | /* Then all cookies in this chain. */ 1438| 1.55k| while (chain) ------------------ | Branch (1438:14): [True: 1.03k, False: 519] ------------------ 1439| 1.03k| { 1440| 1.03k| struct cookie *next = chain->next; 1441| 1.03k| delete_cookie (chain); 1442| 1.03k| chain = next; 1443| 1.03k| } 1444| 519| } 1445| 1.86k| hash_table_destroy (jar->chains); 1446| 1.86k| xfree (jar); ------------------ | | 54| 1.86k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 1447| | 1448| 1.86k|#ifdef HAVE_LIBPSL 1449| 1.86k| psl_free (psl); 1450| 1.86k| psl = NULL; 1451| 1.86k|#endif 1452| 1.86k|} cookies.c:parse_set_cookie: 355| 5.60k|{ 356| 5.60k| const char *ptr = set_cookie; 357| 5.60k| struct cookie *cookie = cookie_new (); 358| 5.60k| param_token name, value; 359| | 360| 5.60k| if (!extract_param (&ptr, &name, &value, ';', NULL)) ------------------ | Branch (360:7): [True: 417, False: 5.18k] ------------------ 361| 417| goto error; 362| 5.18k| if (!value.b) ------------------ | Branch (362:7): [True: 2.69k, False: 2.48k] ------------------ 363| 2.69k| goto error; 364| | 365| | /* If the value is quoted, do not modify it. */ 366| 2.48k| if (*(value.b - 1) == '"') ------------------ | Branch (366:7): [True: 153, False: 2.33k] ------------------ 367| 153| value.b--; 368| 2.48k| if (*value.e == '"') ------------------ | Branch (368:7): [True: 153, False: 2.33k] ------------------ 369| 153| value.e++; 370| | 371| 2.48k| cookie->attr = strdupdelim (name.b, name.e); 372| 2.48k| cookie->value = strdupdelim (value.b, value.e); 373| | 374| 27.9k| while (extract_param (&ptr, &name, &value, ';', NULL)) ------------------ | Branch (374:10): [True: 25.5k, False: 2.40k] ------------------ 375| 25.5k| { 376| 25.5k| if (TOKEN_IS (name, "domain")) ------------------ | | 333| 25.5k| BOUNDED_EQUAL_NO_CASE (token.b, token.e, string_literal) | | ------------------ | | | | 203| 25.5k| ((end) - (beg) == sizeof (string_literal) - 1 \ | | | | ------------------ | | | | | Branch (203:4): [True: 2.79k, False: 22.7k] | | | | ------------------ | | | | 204| 25.5k| && !c_strncasecmp (beg, string_literal, sizeof (string_literal) - 1)) | | | | ------------------ | | | | | Branch (204:7): [True: 1.12k, False: 1.67k] | | | | ------------------ | | ------------------ ------------------ 377| 1.12k| { 378| 1.12k| if (!TOKEN_NON_EMPTY (value)) ------------------ | | 335| 1.12k|#define TOKEN_NON_EMPTY(token) (token.b != NULL && token.b != token.e) | | ------------------ | | | Branch (335:33): [True: 1.12k, False: 3] | | | Branch (335:52): [True: 1.12k, False: 3] | | ------------------ ------------------ 379| 6| goto error; 380| 1.12k| xfree (cookie->domain); ------------------ | | 54| 1.12k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 381| | /* Strictly speaking, we should set cookie->domain_exact if the 382| | domain doesn't begin with a dot. But many sites set the 383| | domain to "foo.com" and expect "subhost.foo.com" to get the 384| | cookie, and it apparently works in browsers. */ 385| 1.12k| if (*value.b == '.') ------------------ | Branch (385:15): [True: 456, False: 666] ------------------ 386| 456| ++value.b; 387| 1.12k| cookie->domain = strdupdelim (value.b, value.e); 388| 1.12k| } 389| 24.3k| else if (TOKEN_IS (name, "path")) ------------------ | | 333| 24.3k| BOUNDED_EQUAL_NO_CASE (token.b, token.e, string_literal) | | ------------------ | | | | 203| 24.3k| ((end) - (beg) == sizeof (string_literal) - 1 \ | | | | ------------------ | | | | | Branch (203:4): [True: 4.02k, False: 20.3k] | | | | ------------------ | | | | 204| 24.3k| && !c_strncasecmp (beg, string_literal, sizeof (string_literal) - 1)) | | | | ------------------ | | | | | Branch (204:7): [True: 2.40k, False: 1.61k] | | | | ------------------ | | ------------------ ------------------ 390| 2.40k| { 391| 2.40k| if (!TOKEN_NON_EMPTY (value)) ------------------ | | 335| 2.40k|#define TOKEN_NON_EMPTY(token) (token.b != NULL && token.b != token.e) | | ------------------ | | | Branch (335:33): [True: 2.40k, False: 6] | | | Branch (335:52): [True: 2.40k, False: 3] | | ------------------ ------------------ 392| 9| goto error; 393| 2.40k| xfree (cookie->path); ------------------ | | 54| 2.40k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 394| 2.40k| cookie->path = strdupdelim (value.b, value.e); 395| 2.40k| } 396| 21.9k| else if (TOKEN_IS (name, "expires")) ------------------ | | 333| 21.9k| BOUNDED_EQUAL_NO_CASE (token.b, token.e, string_literal) | | ------------------ | | | | 203| 21.9k| ((end) - (beg) == sizeof (string_literal) - 1 \ | | | | ------------------ | | | | | Branch (203:4): [True: 5.01k, False: 16.9k] | | | | ------------------ | | | | 204| 21.9k| && !c_strncasecmp (beg, string_literal, sizeof (string_literal) - 1)) | | | | ------------------ | | | | | Branch (204:7): [True: 3.38k, False: 1.62k] | | | | ------------------ | | ------------------ ------------------ 397| 3.38k| { 398| 3.38k| char value_copy[128]; 399| 3.38k| size_t value_len = value.e - value.b; 400| 3.38k| time_t expires; 401| | 402| 3.38k| if (!TOKEN_NON_EMPTY (value) || value_len >= sizeof (value_copy)) ------------------ | | 335| 6.76k|#define TOKEN_NON_EMPTY(token) (token.b != NULL && token.b != token.e) | | ------------------ | | | Branch (335:33): [True: 3.37k, False: 3] | | | Branch (335:52): [True: 3.37k, False: 6] | | ------------------ ------------------ | Branch (402:43): [True: 15, False: 3.35k] ------------------ 403| 24| goto error; 404| | 405| 3.35k| memcpy (value_copy, value.b, value_len); 406| 3.35k| value_copy[value_len] = 0; 407| | 408| | /* Check if expiration spec is valid. 409| | If not, assume default (cookie doesn't expire, but valid only for 410| | this session.) */ 411| 3.35k| expires = http_atotm (value_copy); 412| 3.35k| if (expires != (time_t) -1) ------------------ | Branch (412:15): [True: 1.56k, False: 1.79k] ------------------ 413| 1.56k| { 414| 1.56k| cookie->permanent = 1; 415| 1.56k| cookie->expiry_time = expires; 416| | /* According to netscape's specification, expiry time in 417| | the past means that discarding of a matching cookie 418| | is requested. */ 419| 1.56k| if (cookie->expiry_time < cookies_now) ------------------ | Branch (419:19): [True: 1.35k, False: 207] ------------------ 420| 1.35k| cookie->discard_requested = 1; 421| 1.56k| } 422| 3.35k| } 423| 18.6k| else if (TOKEN_IS (name, "max-age")) ------------------ | | 333| 18.6k| BOUNDED_EQUAL_NO_CASE (token.b, token.e, string_literal) | | ------------------ | | | | 203| 18.6k| ((end) - (beg) == sizeof (string_literal) - 1 \ | | | | ------------------ | | | | | Branch (203:4): [True: 1.62k, False: 16.9k] | | | | ------------------ | | | | 204| 18.6k| && !c_strncasecmp (beg, string_literal, sizeof (string_literal) - 1)) | | | | ------------------ | | | | | Branch (204:7): [True: 1.01k, False: 612] | | | | ------------------ | | ------------------ ------------------ 424| 1.01k| { 425| 1.01k| double maxage = -1; 426| 1.01k| char value_copy[32]; 427| 1.01k| size_t value_len = value.e - value.b; 428| | 429| 1.01k| if (!TOKEN_NON_EMPTY (value) || value_len >= sizeof (value_copy)) ------------------ | | 335| 2.03k|#define TOKEN_NON_EMPTY(token) (token.b != NULL && token.b != token.e) | | ------------------ | | | Branch (335:33): [True: 1.01k, False: 6] | | | Branch (335:52): [True: 1.00k, False: 3] | | ------------------ ------------------ | Branch (429:43): [True: 21, False: 987] ------------------ 430| 30| goto error; 431| | 432| 987| memcpy (value_copy, value.b, value_len); 433| 987| value_copy[value_len] = 0; 434| | 435| 987| sscanf (value_copy, "%lf", &maxage); 436| 987| if (maxage == -1) ------------------ | Branch (436:15): [True: 18, False: 969] ------------------ 437| | /* something went wrong. */ 438| 18| goto error; 439| 969| cookie->permanent = 1; 440| 969| cookie->expiry_time = cookies_now + (time_t) maxage; 441| | 442| | /* According to rfc2109, a cookie with max-age of 0 means that 443| | discarding of a matching cookie is requested. */ 444| 969| if (maxage == 0) ------------------ | Branch (444:15): [True: 501, False: 468] ------------------ 445| 501| cookie->discard_requested = 1; 446| 969| } 447| 17.5k| else if (TOKEN_IS (name, "secure")) ------------------ | | 333| 17.5k| BOUNDED_EQUAL_NO_CASE (token.b, token.e, string_literal) | | ------------------ | | | | 203| 17.5k| ((end) - (beg) == sizeof (string_literal) - 1 \ | | | | ------------------ | | | | | Branch (203:4): [True: 1.67k, False: 15.9k] | | | | ------------------ | | | | 204| 17.5k| && !c_strncasecmp (beg, string_literal, sizeof (string_literal) - 1)) | | | | ------------------ | | | | | Branch (204:7): [True: 519, False: 1.15k] | | | | ------------------ | | ------------------ ------------------ 448| 519| { 449| | /* ignore value completely */ 450| 519| cookie->secure = 1; 451| 519| } 452| | /* else: Ignore unrecognized attribute. */ 453| 25.5k| } 454| 2.40k| if (*ptr) ------------------ | Branch (454:7): [True: 54, False: 2.34k] ------------------ 455| | /* extract_param has encountered a syntax error */ 456| 54| goto error; 457| | 458| | /* The cookie has been successfully constructed; return it. */ 459| 2.34k| return cookie; 460| | 461| 3.25k| error: 462| 3.25k| if (!silent) ------------------ | Branch (462:7): [True: 3.25k, False: 0] ------------------ 463| 3.25k| logprintf (LOG_NOTQUIET, 464| 3.25k| _("Syntax error in Set-Cookie: %s at position %d.\n"), ------------------ | | 64| 3.25k|#define _(STRING) gettext(STRING) ------------------ 465| 3.25k| quotearg_style (escape_quoting_style, set_cookie), 466| 3.25k| (int) (ptr - set_cookie)); 467| 3.25k| delete_cookie (cookie); 468| 3.25k| return NULL; 469| 2.40k|} cookies.c:check_domain_match: 536| 207|{ 537| 207|#ifdef HAVE_LIBPSL 538| 207| static int init_psl; 539| 207| char *cookie_domain_lower = NULL; 540| 207| char *host_lower = NULL; 541| 207| int is_acceptable; 542| | 543| 207| DEBUGP (("cdm: 1\n")); ------------------ | | 129| 207|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 207|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 207|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 207] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 544| 207| if (!init_psl) ------------------ | Branch (544:7): [True: 1, False: 206] ------------------ 545| 1| { 546| 1| init_psl = 1; 547| | 548| 1|#ifdef HAVE_PSL_LATEST 549| 1| if ((psl = psl_latest (NULL))) ------------------ | Branch (549:11): [True: 1, False: 0] ------------------ 550| 1| goto have_psl; 551| | 552| 0| DEBUGP (("\nPSL: Failed to load any PSL data. " ------------------ | | 129| 0|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 0|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 0|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 553| 0| "Falling back to insecure heuristics.\n")); 554| |#else 555| | if ((psl = psl_builtin ()) && !psl_builtin_outdated ()) 556| | goto have_psl; 557| | 558| | DEBUGP (("\nPSL: built-in data outdated. " 559| | "Trying to load data from %s.\n", 560| | quote (psl_builtin_filename ()))); 561| | 562| | if ((psl = psl_load_file (psl_builtin_filename ()))) 563| | goto have_psl; 564| | 565| | DEBUGP (("\nPSL: %s not found or not readable. " 566| | "Falling back to built-in data.\n", 567| | quote (psl_builtin_filename ()))); 568| | 569| | if (!(psl = psl_builtin ())) 570| | { 571| | DEBUGP (("\nPSL: libpsl not built with a public suffix list. " 572| | "Falling back to insecure heuristics.\n")); 573| | goto no_psl; 574| | } 575| |#endif 576| 0| } 577| 206| else if (!psl) ------------------ | Branch (577:12): [True: 204, False: 2] ------------------ 578| 204| goto no_psl; 579| | 580| 3|have_psl: 581| 3| if (psl_str_to_utf8lower (cookie_domain, NULL, NULL, &cookie_domain_lower) == PSL_SUCCESS && ------------------ | Branch (581:7): [True: 3, False: 0] ------------------ 582| 3| psl_str_to_utf8lower (host, NULL, NULL, &host_lower) == PSL_SUCCESS) ------------------ | Branch (582:7): [True: 3, False: 0] ------------------ 583| 3| { 584| 3| is_acceptable = psl_is_cookie_domain_acceptable (psl, host_lower, cookie_domain_lower); 585| 3| } 586| 0| else 587| 0| { 588| 0| DEBUGP (("libpsl unable to parse domain name. " ------------------ | | 129| 0|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 0|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 0|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 589| 0| "Falling back to simple heuristics.\n")); 590| 0| goto no_psl; 591| 0| } 592| | 593| 3| xfree (cookie_domain_lower); ------------------ | | 54| 3|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 594| 3| xfree (host_lower); ------------------ | | 54| 3|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 595| | 596| 3| return is_acceptable == 1; 597| | 598| 204|no_psl: 599| | /* Cleanup the PSL pointers first */ 600| 204| xfree (cookie_domain_lower); ------------------ | | 54| 204|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 601| 204| xfree (host_lower); ------------------ | | 54| 204|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 602| 204|#endif 603| | 604| | /* For efficiency make some elementary checks first */ 605| 204| DEBUGP (("cdm: 2\n")); ------------------ | | 129| 204|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 204|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 204|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 204] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 606| | 607| | /* For the sake of efficiency, check for exact match first. */ 608| 204| if (0 == strcasecmp (cookie_domain, host)) ------------------ | Branch (608:7): [True: 30, False: 174] ------------------ 609| 30| return true; 610| | 611| 174| DEBUGP (("cdm: 3\n")); ------------------ | | 129| 174|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 174|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 174|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 174] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 612| | 613| | /* HOST must match the tail of cookie_domain. */ 614| 174| if (!match_tail (host, cookie_domain, true)) ------------------ | Branch (614:7): [True: 153, False: 21] ------------------ 615| 153| return false; 616| | 617| | /* We know that COOKIE_DOMAIN is a subset of HOST; however, we must 618| | make sure that somebody is not trying to set the cookie for a 619| | subdomain shared by many entities. For example, "company.co.uk" 620| | must not be allowed to set a cookie for ".co.uk". On the other 621| | hand, "sso.redhat.de" should be able to set a cookie for 622| | ".redhat.de". 623| | 624| | The only marginally sane way to handle this I can think of is to 625| | reject on the basis of the length of the second-level domain name 626| | (but when the top-level domain is unknown), with the assumption 627| | that those of three or less characters could be reserved. For 628| | example: 629| | 630| | .co.org -> works because the TLD is known 631| | .co.uk -> doesn't work because "co" is only two chars long 632| | .com.au -> doesn't work because "com" is only 3 chars long 633| | .cnn.uk -> doesn't work because "cnn" is also only 3 chars long (ugh) 634| | .cnn.de -> doesn't work for the same reason (ugh!!) 635| | .abcd.de -> works because "abcd" is 4 chars long 636| | .img.cnn.de -> works because it's not trying to set the 2nd level domain 637| | .cnn.co.uk -> works for the same reason 638| | 639| | That should prevent misuse, while allowing reasonable usage. If 640| | someone knows of a better way to handle this, please let me 641| | know. */ 642| 21| { 643| 21| const char *p = cookie_domain; 644| 21| int dccount = 1; /* number of domain components */ 645| 21| int ldcl = 0; /* last domain component length */ 646| 21| int nldcl = 0; /* next to last domain component length */ 647| 21| int out; 648| 21| if (*p == '.') ------------------ | Branch (648:9): [True: 0, False: 21] ------------------ 649| | /* Ignore leading period in this calculation. */ 650| 0| ++p; 651| 21| DEBUGP (("cdm: 4\n")); ------------------ | | 129| 21|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 21|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 21|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 21] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 652| 42| for (out = 0; !out; p++) ------------------ | Branch (652:19): [True: 21, False: 21] ------------------ 653| 21| switch (*p) 654| 21| { 655| 21| case '\0': ------------------ | Branch (655:9): [True: 21, False: 0] ------------------ 656| 21| out = 1; 657| 21| break; 658| 0| case '.': ------------------ | Branch (658:9): [True: 0, False: 21] ------------------ 659| 0| if (ldcl == 0) ------------------ | Branch (659:15): [True: 0, False: 0] ------------------ 660| | /* Empty domain component found -- the domain is invalid. */ 661| 0| return false; 662| 0| if (*(p + 1) == '\0') ------------------ | Branch (662:15): [True: 0, False: 0] ------------------ 663| 0| { 664| | /* Tolerate trailing '.' by not treating the domain as 665| | one ending with an empty domain component. */ 666| 0| out = 1; 667| 0| break; 668| 0| } 669| 0| nldcl = ldcl; 670| 0| ldcl = 0; 671| 0| ++dccount; 672| 0| break; 673| 0| default: ------------------ | Branch (673:9): [True: 0, False: 21] ------------------ 674| 0| ++ldcl; 675| 21| } 676| | 677| 21| DEBUGP (("cdm: 5\n")); ------------------ | | 129| 21|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 21|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 21|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 21] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 678| | 679| 21| if (dccount < 2) ------------------ | Branch (679:9): [True: 21, False: 0] ------------------ 680| 21| return false; 681| | 682| 0| DEBUGP (("cdm: 6\n")); ------------------ | | 129| 0|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 0|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 0|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 683| | 684| 0| if (dccount == 2) ------------------ | Branch (684:9): [True: 0, False: 0] ------------------ 685| 0| { 686| 0| size_t i; 687| 0| int known_toplevel = false; 688| 0| static const char *known_toplevel_domains[] = { 689| 0| ".com", ".edu", ".net", ".org", ".gov", ".mil", ".int" 690| 0| }; 691| 0| for (i = 0; i < countof (known_toplevel_domains); i++) ------------------ | | 175| 0|#define countof(array) (sizeof (array) / sizeof ((array)[0])) ------------------ | Branch (691:21): [True: 0, False: 0] ------------------ 692| 0| if (match_tail (cookie_domain, known_toplevel_domains[i], true)) ------------------ | Branch (692:15): [True: 0, False: 0] ------------------ 693| 0| { 694| 0| known_toplevel = true; 695| 0| break; 696| 0| } 697| 0| if (!known_toplevel && nldcl <= 3) ------------------ | Branch (697:13): [True: 0, False: 0] | Branch (697:32): [True: 0, False: 0] ------------------ 698| 0| return false; 699| 0| } 700| 0| } 701| | 702| 0| DEBUGP (("cdm: 7\n")); ------------------ | | 129| 0|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 0|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 0|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 703| | 704| | /* Don't allow the host "foobar.com" to set a cookie for domain 705| | "bar.com". */ 706| 0| if (*cookie_domain != '.') ------------------ | Branch (706:7): [True: 0, False: 0] ------------------ 707| 0| { 708| 0| int dlen = strlen (cookie_domain); 709| 0| int hlen = strlen (host); 710| | /* cookie host: hostname.foobar.com */ 711| | /* desired domain: bar.com */ 712| | /* '.' must be here in host-> ^ */ 713| 0| if (hlen > dlen && host[hlen - dlen - 1] != '.') ------------------ | Branch (713:11): [True: 0, False: 0] | Branch (713:26): [True: 0, False: 0] ------------------ 714| 0| return false; 715| 0| } 716| | 717| 0| DEBUGP (("cdm: 8\n")); ------------------ | | 129| 0|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 0|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 0|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 718| | 719| 0| return true; 720| 0|} cookies.c:check_path_match: 728| 195|{ 729| 195| return path_matches (path, cookie_path) != 0; 730| 195|} cookies.c:path_matches: 902| 195|{ 903| 195| int len = strlen (prefix); 904| | 905| 195| if (0 != strncmp (full_path, prefix, len)) ------------------ | Branch (905:7): [True: 162, False: 33] ------------------ 906| | /* FULL_PATH doesn't begin with PREFIX. */ 907| 162| return 0; 908| | 909| | /* Length of PREFIX determines the quality of the match. */ 910| 33| return len + 1; 911| 195|} cookies.c:discard_matching_cookie: 286| 631|{ 287| 631| struct cookie *prev, *victim; 288| | 289| 631| if (!hash_table_count (jar->chains)) ------------------ | Branch (289:7): [True: 631, False: 0] ------------------ 290| | /* No elements == nothing to discard. */ 291| 631| return; 292| | 293| 0| victim = find_matching_cookie (jar, cookie, &prev); 294| 0| if (victim) ------------------ | Branch (294:7): [True: 0, False: 0] ------------------ 295| 0| { 296| 0| if (prev) ------------------ | Branch (296:11): [True: 0, False: 0] ------------------ 297| | /* Simply unchain the victim. */ 298| 0| prev->next = victim->next; 299| 0| else 300| 0| { 301| | /* VICTIM was head of its chain. We need to place a new 302| | cookie at the head. */ 303| 0| char *chain_key = NULL; 304| 0| int res; 305| | 306| 0| res = hash_table_get_pair (jar->chains, victim->domain, 307| 0| &chain_key, NULL); 308| | 309| 0| if (res == 0) ------------------ | Branch (309:15): [True: 0, False: 0] ------------------ 310| 0| { 311| 0| logprintf (LOG_VERBOSE, _("Unable to get cookie for %s\n"), ------------------ | | 64| 0|#define _(STRING) gettext(STRING) ------------------ 312| 0| victim->domain); 313| 0| } 314| 0| if (!victim->next) ------------------ | Branch (314:15): [True: 0, False: 0] ------------------ 315| 0| { 316| | /* VICTIM was the only cookie in the chain. Destroy the 317| | chain and deallocate the chain key. */ 318| 0| hash_table_remove (jar->chains, victim->domain); 319| 0| xfree (chain_key); ------------------ | | 54| 0|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 320| 0| } 321| 0| else 322| 0| hash_table_put (jar->chains, chain_key, victim->next); 323| 0| } 324| 0| delete_cookie (victim); 325| 0| DEBUGP (("Discarded old cookie.\n")); ------------------ | | 129| 0|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 0|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 0|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 326| 0| } 327| 0|} cookies.c:find_matching_cookie: 181| 1.03k|{ 182| 1.03k| struct cookie *chain, *prev; 183| | 184| 1.03k| chain = hash_table_get (jar->chains, cookie->domain); 185| 1.03k| if (!chain) ------------------ | Branch (185:7): [True: 0, False: 1.03k] ------------------ 186| 0| goto nomatch; 187| | 188| 1.03k| prev = NULL; 189| 1.54k| for (; chain; prev = chain, chain = chain->next) ------------------ | Branch (189:10): [True: 1.03k, False: 515] ------------------ 190| 1.03k| if (0 == strcmp (cookie->path, chain->path) ------------------ | Branch (190:9): [True: 523, False: 511] ------------------ 191| 1.03k| && 0 == strcmp (cookie->attr, chain->attr) ------------------ | Branch (191:12): [True: 523, False: 0] ------------------ 192| 1.03k| && cookie->port == chain->port) ------------------ | Branch (192:12): [True: 519, False: 4] ------------------ 193| 519| { 194| 519| *prevptr = prev; 195| 519| return chain; 196| 519| } 197| | 198| 515| nomatch: 199| 515| *prevptr = NULL; 200| 515| return NULL; 201| 1.03k|} cookies.c:store_cookie: 214| 1.55k|{ 215| 1.55k| struct cookie *chain_head; 216| 1.55k| char *chain_key; 217| | 218| 1.55k| if (hash_table_get_pair (jar->chains, cookie->domain, ------------------ | Branch (218:7): [True: 1.03k, False: 519] ------------------ 219| 1.55k| &chain_key, &chain_head)) 220| 1.03k| { 221| | /* A chain of cookies in this domain already exists. Check for 222| | duplicates -- if an extant cookie exactly matches our domain, 223| | port, path, and name, replace it. */ 224| 1.03k| struct cookie *prev; 225| 1.03k| struct cookie *victim = find_matching_cookie (jar, cookie, &prev); 226| | 227| 1.03k| if (victim) ------------------ | Branch (227:11): [True: 519, False: 515] ------------------ 228| 519| { 229| | /* Remove VICTIM from the chain. COOKIE will be placed at 230| | the head. */ 231| 519| if (prev) ------------------ | Branch (231:15): [True: 0, False: 519] ------------------ 232| 0| { 233| 0| prev->next = victim->next; 234| 0| cookie->next = chain_head; 235| 0| } 236| 519| else 237| 519| { 238| | /* prev is NULL; apparently VICTIM was at the head of 239| | the chain. This place will be taken by COOKIE, so 240| | all we need to do is: */ 241| 519| cookie->next = victim->next; 242| 519| } 243| 519| delete_cookie (victim); 244| 519| --jar->cookie_count; 245| 519| DEBUGP (("Deleted old cookie (to be replaced.)\n")); ------------------ | | 129| 519|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 519|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 519|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 519] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 246| 519| } 247| 515| else 248| 515| cookie->next = chain_head; 249| 1.03k| } 250| 519| else 251| 519| { 252| | /* We are now creating the chain. Use a copy of cookie->domain 253| | as the key for the life-time of the chain. Using 254| | cookie->domain would be unsafe because the life-time of the 255| | chain may exceed the life-time of the cookie. (Cookies may 256| | be deleted from the chain by this very function.) */ 257| 519| cookie->next = NULL; 258| 519| chain_key = xstrdup (cookie->domain); 259| 519| } 260| | 261| 1.55k| hash_table_put (jar->chains, chain_key, cookie); 262| 1.55k| ++jar->cookie_count; 263| | 264| 1.55k| IF_DEBUG ------------------ | | 119| 1.55k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | ------------------ | | | | 108| 1.55k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | ------------------ | | | | | Branch (108:24): [True: 0, False: 1.55k] | | | | ------------------ | | ------------------ ------------------ 265| 0| { 266| 0| time_t exptime = cookie->expiry_time; 267| 0| DEBUGP (("\nStored cookie %s %d%s %s <%s> <%s> [expiry %s] %s %s\n", ------------------ | | 129| 0|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 0|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 0|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:54): [True: 0, False: 0] | | | Branch (129:54): [True: 0, False: 0] | | | Branch (129:54): [True: 0, False: 0] | | | Branch (129:54): [True: 0, False: 0] | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 268| 0| cookie->domain, cookie->port, 269| 0| cookie->port == PORT_ANY ? " (ANY)" : "", 270| 0| cookie->path, 271| 0| cookie->permanent ? "permanent" : "session", 272| 0| cookie->secure ? "secure" : "insecure", 273| 0| cookie->expiry_time ? datetime_str (exptime) : "none", 274| 0| cookie->attr, cookie->value)); 275| 0| } 276| 1.55k|} cookies.c:delete_cookie: 156| 5.60k|{ 157| 5.60k| xfree (cookie->domain); ------------------ | | 54| 5.60k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 158| 5.60k| xfree (cookie->path); ------------------ | | 54| 5.60k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 159| 5.60k| xfree (cookie->attr); ------------------ | | 54| 5.60k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 160| 5.60k| xfree (cookie->value); ------------------ | | 54| 5.60k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 161| 5.60k| xfree (cookie); ------------------ | | 54| 5.60k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 162| 5.60k|} cookies.c:cookie_new: 132| 5.60k|{ 133| 5.60k| struct cookie *cookie = xnew0 (struct cookie); ------------------ | | 50| 5.60k|#define xnew0(type) (xcalloc (1, sizeof (type))) ------------------ 134| | 135| | /* Both cookie->permanent and cookie->expiry_time are now 0. This 136| | means that the cookie doesn't expire, but is only valid for this 137| | session (i.e. not written out to disk). */ 138| | 139| 5.60k| cookie->port = PORT_ANY; ------------------ | | 126| 5.60k|#define PORT_ANY (-1) ------------------ 140| 5.60k| return cookie; 141| 5.60k|} hash_table_new: 273| 1.86k|{ 274| 1.86k| int size; 275| 1.86k| struct hash_table *ht = xnew (struct hash_table); ------------------ | | 49| 1.86k|#define xnew(type) (xmalloc (sizeof (type))) ------------------ 276| | 277| 1.86k| ht->hash_function = hash_function ? hash_function : hash_pointer; ------------------ | Branch (277:23): [True: 1.86k, False: 0] ------------------ 278| 1.86k| ht->test_function = test_function ? test_function : cmp_pointer; ------------------ | Branch (278:23): [True: 1.86k, False: 0] ------------------ 279| | 280| | /* If the size of struct hash_table ever becomes a concern, this 281| | field can go. (Wget doesn't create many hashes.) */ 282| 1.86k| ht->prime_offset = 0; 283| | 284| | /* Calculate the size that ensures that the table will store at 285| | least ITEMS keys without the need to resize. */ 286| 1.86k| size = (int) (1 + items / HASH_MAX_FULLNESS); ------------------ | | 138| 1.86k|#define HASH_MAX_FULLNESS 0.75 ------------------ 287| 1.86k| size = prime_size (size, &ht->prime_offset); 288| 1.86k| ht->size = size; 289| 1.86k| ht->resize_threshold = (int) (size * HASH_MAX_FULLNESS); ------------------ | | 138| 1.86k|#define HASH_MAX_FULLNESS 0.75 ------------------ 290| | /*assert (ht->resize_threshold >= items);*/ 291| | 292| 1.86k| ht->cells = xnew_array (struct cell, ht->size); ------------------ | | 51| 1.86k|#define xnew_array(type, len) (xmalloc ((len) * sizeof (type))) ------------------ 293| | 294| | /* Mark cells as empty. We use 0xff rather than 0 to mark empty 295| | keys because it allows us to use NULL/0 as keys. */ 296| 1.86k| memset (ht->cells, INVALID_PTR_CHAR, size * sizeof (struct cell)); ------------------ | | 182| 1.86k|#define INVALID_PTR_CHAR UCHAR_MAX ------------------ 297| | 298| 1.86k| ht->count = 0; 299| | 300| 1.86k| return ht; 301| 1.86k|} hash_table_destroy: 307| 1.86k|{ 308| 1.86k| xfree (ht->cells); ------------------ | | 54| 1.86k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 309| 1.86k| xfree (ht); ------------------ | | 54| 1.86k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 310| 1.86k|} hash_table_get: 339| 1.03k|{ 340| 1.03k| struct cell *c = find_cell (ht, key); 341| 1.03k| if (CELL_OCCUPIED (c)) ------------------ | | 185| 1.03k|#define CELL_OCCUPIED(c) ((c)->key != INVALID_PTR) | | ------------------ | | | | 178| 1.03k|#define INVALID_PTR ((void *) ~(uintptr_t) 0) | | ------------------ | | | Branch (185:26): [True: 1.03k, False: 0] | | ------------------ ------------------ 342| 1.03k| return c->value; 343| 0| else 344| 0| return NULL; 345| 1.03k|} hash_table_get_pair: 353| 1.55k|{ 354| 1.55k| struct cell *c = find_cell (ht, lookup_key); 355| 1.55k| if (CELL_OCCUPIED (c)) ------------------ | | 185| 1.55k|#define CELL_OCCUPIED(c) ((c)->key != INVALID_PTR) | | ------------------ | | | | 178| 1.55k|#define INVALID_PTR ((void *) ~(uintptr_t) 0) | | ------------------ | | | Branch (185:26): [True: 1.03k, False: 519] | | ------------------ ------------------ 356| 1.03k| { 357| 1.03k| if (orig_key) ------------------ | Branch (357:11): [True: 1.03k, False: 0] ------------------ 358| 1.03k| *(void **)orig_key = c->key; 359| 1.03k| if (value) ------------------ | Branch (359:11): [True: 1.03k, False: 0] ------------------ 360| 1.03k| *(void **)value = c->value; 361| 1.03k| return 1; 362| 1.03k| } 363| 519| else 364| 519| return 0; 365| 1.55k|} hash_table_put: 424| 1.55k|{ 425| 1.55k| struct cell *c = find_cell (ht, key); 426| 1.55k| if (CELL_OCCUPIED (c)) ------------------ | | 185| 1.55k|#define CELL_OCCUPIED(c) ((c)->key != INVALID_PTR) | | ------------------ | | | | 178| 1.55k|#define INVALID_PTR ((void *) ~(uintptr_t) 0) | | ------------------ | | | Branch (185:26): [True: 1.03k, False: 519] | | ------------------ ------------------ 427| 1.03k| { 428| | /* update existing item */ 429| 1.03k| c->key = (void *)key; /* const? */ 430| 1.03k| c->value = (void *)value; 431| 1.03k| return; 432| 1.03k| } 433| | 434| | /* If adding the item would make the table exceed max. fullness, 435| | grow the table first. */ 436| 519| if (ht->count >= ht->resize_threshold) ------------------ | Branch (436:7): [True: 0, False: 519] ------------------ 437| 0| { 438| 0| grow_hash_table (ht); 439| 0| c = find_cell (ht, key); 440| 0| } 441| | 442| | /* add new item */ 443| 519| ++ht->count; 444| 519| c->key = (void *)key; /* const? */ 445| 519| c->value = (void *)value; 446| 519|} hash_table_iterate: 550| 1.86k|{ 551| 1.86k| iter->pos = ht->cells; 552| 1.86k| iter->end = ht->cells + ht->size; 553| 1.86k|} hash_table_iter_next: 566| 2.38k|{ 567| 2.38k| struct cell *c = iter->pos; 568| 2.38k| struct cell *end = iter->end; 569| 26.1k| for (; c < end; c++) ------------------ | Branch (569:10): [True: 24.2k, False: 1.86k] ------------------ 570| 24.2k| if (CELL_OCCUPIED (c)) ------------------ | | 185| 24.2k|#define CELL_OCCUPIED(c) ((c)->key != INVALID_PTR) | | ------------------ | | | | 178| 24.2k|#define INVALID_PTR ((void *) ~(uintptr_t) 0) | | ------------------ | | | Branch (185:26): [True: 519, False: 23.7k] | | ------------------ ------------------ 571| 519| { 572| 519| iter->key = c->key; 573| 519| iter->value = c->value; 574| 519| iter->pos = c + 1; 575| 519| return 1; 576| 519| } 577| 1.86k| return 0; 578| 2.38k|} hash_table_count: 586| 631|{ 587| 631| return ht->count; 588| 631|} make_nocase_string_hash_table: 708| 1.86k|{ 709| 1.86k| return hash_table_new (items, hash_string_nocase, string_cmp_nocase); 710| 1.86k|} hash.c:prime_size: 214| 1.86k|{ 215| 1.86k| static const int primes[] = { 216| 1.86k| 13, 19, 29, 41, 59, 79, 107, 149, 197, 263, 347, 457, 599, 787, 1031, 217| 1.86k| 1361, 1777, 2333, 3037, 3967, 5167, 6719, 8737, 11369, 14783, 218| 1.86k| 19219, 24989, 32491, 42257, 54941, 71429, 92861, 120721, 156941, 219| 1.86k| 204047, 265271, 344857, 448321, 582821, 757693, 985003, 1280519, 220| 1.86k| 1664681, 2164111, 2813353, 3657361, 4754591, 6180989, 8035301, 221| 1.86k| 10445899, 13579681, 17653589, 22949669, 29834603, 38784989, 222| 1.86k| 50420551, 65546729, 85210757, 110774011, 144006217, 187208107, 223| 1.86k| 243370577, 316381771, 411296309, 534685237, 695090819, 903618083, 224| 1.86k| 1174703521, 1527114613, 1837299131, 2147483647 225| 1.86k| }; 226| 1.86k| size_t i; 227| | 228| 1.86k| for (i = *prime_offset; i < countof (primes); i++) ------------------ | | 175| 1.86k|#define countof(array) (sizeof (array) / sizeof ((array)[0])) ------------------ | Branch (228:27): [True: 1.86k, False: 0] ------------------ 229| 1.86k| if (primes[i] >= size) ------------------ | Branch (229:9): [True: 1.86k, False: 0] ------------------ 230| 1.86k| { 231| | /* Set the offset to the next prime. That is safe because, 232| | next time we are called, it will be with a larger SIZE, 233| | which means we could never return the same prime anyway. 234| | (If that is not the case, the caller can simply reset 235| | *prime_offset.) */ 236| 1.86k| *prime_offset = i + 1; 237| 1.86k| return primes[i]; 238| 1.86k| } 239| | 240| 0| abort (); 241| 1.86k|} hash.c:find_cell: 318| 4.14k|{ 319| 4.14k| struct cell *cells = ht->cells; 320| 4.14k| int size = ht->size; 321| 4.14k| struct cell *c = cells + HASH_POSITION (key, ht->hash_function, size); ------------------ | | 201| 4.14k|#define HASH_POSITION(key, hashfun, size) ((hashfun) (key) % size) ------------------ 322| 4.14k| testfun_t equals = ht->test_function; 323| | 324| 4.14k| FOREACH_OCCUPIED_ADJACENT (c, cells, size) ------------------ | | 197| 4.14k| for (; CELL_OCCUPIED (c); c = NEXT_CELL (c, cells, size)) | | ------------------ | | | | 185| 4.14k|#define CELL_OCCUPIED(c) ((c)->key != INVALID_PTR) | | | | ------------------ | | | | | | 178| 4.14k|#define INVALID_PTR ((void *) ~(uintptr_t) 0) | | | | ------------------ | | | | | Branch (185:26): [True: 3.10k, False: 1.03k] | | | | ------------------ | | ------------------ | | for (; CELL_OCCUPIED (c); c = NEXT_CELL (c, cells, size)) | | ------------------ | | | | 192| 0|#define NEXT_CELL(c, cells, size) (c != cells + (size - 1) ? c + 1 : cells) | | | | ------------------ | | | | | Branch (192:36): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 325| 3.10k| if (equals (key, c->key)) ------------------ | Branch (325:9): [True: 3.10k, False: 0] ------------------ 326| 3.10k| break; 327| 4.14k| return c; 328| 4.14k|} hash.c:hash_string_nocase: 684| 4.14k|{ 685| 4.14k| const char *p = key; 686| 4.14k| unsigned int h = c_tolower (*p); 687| | 688| 4.14k| if (h) ------------------ | Branch (688:7): [True: 4.14k, False: 0] ------------------ 689| 4.14k| for (p += 1; *p != '\0'; p++) ------------------ | Branch (689:18): [True: 0, False: 4.14k] ------------------ 690| 0| h = (h << 5) - h + c_tolower (*p); 691| | 692| 4.14k| return h; 693| 4.14k|} hash.c:string_cmp_nocase: 699| 3.10k|{ 700| 3.10k| return !strcasecmp ((const char *)s1, (const char *)s2); 701| 3.10k|} extract_param: 1132| 33.5k|{ 1133| 33.5k| const char *p = *source; 1134| 33.5k| int param_type; 1135| 33.5k| if (is_url_encoded) ------------------ | Branch (1135:7): [True: 0, False: 33.5k] ------------------ 1136| 0| *is_url_encoded = false; /* initializing the out parameter */ 1137| | 1138| 39.3k| while (c_isspace (*p)) ++p; ------------------ | Branch (1138:10): [True: 5.86k, False: 33.5k] ------------------ 1139| 33.5k| if (!*p) ------------------ | Branch (1139:7): [True: 2.49k, False: 31.0k] ------------------ 1140| 2.49k| { 1141| 2.49k| *source = p; 1142| 2.49k| return false; /* no error; nothing more to extract */ 1143| 2.49k| } 1144| | 1145| | /* Extract name. */ 1146| 31.0k| name->b = p; 1147| 279k| while (*p && !c_isspace (*p) && *p != '=' && *p != separator) ++p; ------------------ | Branch (1147:10): [True: 276k, False: 3.09k] | Branch (1147:16): [True: 274k, False: 1.20k] | Branch (1147:35): [True: 256k, False: 18.2k] | Branch (1147:48): [True: 248k, False: 8.44k] ------------------ 1148| 31.0k| name->e = p; 1149| 31.0k| if (name->b == name->e) ------------------ | Branch (1149:7): [True: 90, False: 30.9k] ------------------ 1150| 90| return false; /* empty name: error */ 1151| 33.5k| while (c_isspace (*p)) ++p; ------------------ | Branch (1151:10): [True: 2.64k, False: 30.9k] ------------------ 1152| 30.9k| if (*p == separator || !*p) /* no value */ ------------------ | Branch (1152:7): [True: 9.33k, False: 21.6k] | Branch (1152:26): [True: 3.18k, False: 18.4k] ------------------ 1153| 12.5k| { 1154| 12.5k| xzero (*value); ------------------ | | 178| 12.5k|#define xzero(x) memset (&(x), '\0', sizeof (x)) ------------------ 1155| 12.5k| if (*p == separator) ++p; ------------------ | Branch (1155:11): [True: 9.33k, False: 3.18k] ------------------ 1156| 12.5k| *source = p; 1157| 12.5k| return true; 1158| 12.5k| } 1159| 18.4k| if (*p != '=') ------------------ | Branch (1159:7): [True: 168, False: 18.2k] ------------------ 1160| 168| return false; /* error */ 1161| | 1162| | /* *p is '=', extract value */ 1163| 18.2k| ++p; 1164| 19.2k| while (c_isspace (*p)) ++p; ------------------ | Branch (1164:10): [True: 975, False: 18.2k] ------------------ 1165| 18.2k| if (*p == '"') /* quoted */ ------------------ | Branch (1165:7): [True: 1.21k, False: 17.0k] ------------------ 1166| 1.21k| { 1167| 1.21k| value->b = ++p; 1168| 2.47k| while (*p && *p != '"') ++p; ------------------ | Branch (1168:14): [True: 2.41k, False: 63] | Branch (1168:20): [True: 1.26k, False: 1.15k] ------------------ 1169| 1.21k| if (!*p) ------------------ | Branch (1169:11): [True: 63, False: 1.15k] ------------------ 1170| 63| return false; 1171| 1.15k| value->e = p++; 1172| | /* Currently at closing quote; find the end of param. */ 1173| 2.12k| while (c_isspace (*p)) ++p; ------------------ | Branch (1173:14): [True: 972, False: 1.15k] ------------------ 1174| 2.18k| while (*p && *p != separator) ++p; ------------------ | Branch (1174:14): [True: 2.05k, False: 129] | Branch (1174:20): [True: 1.03k, False: 1.02k] ------------------ 1175| 1.15k| if (*p == separator) ------------------ | Branch (1175:11): [True: 1.02k, False: 129] ------------------ 1176| 1.02k| ++p; 1177| 129| else if (*p) ------------------ | Branch (1177:16): [True: 0, False: 129] ------------------ 1178| | /* garbage after closed quote, e.g. foo="bar"baz */ 1179| 0| return false; 1180| 1.15k| } 1181| 17.0k| else /* unquoted */ 1182| 17.0k| { 1183| 17.0k| value->b = p; 1184| 88.5k| while (*p && *p != separator) ++p; ------------------ | Branch (1184:14): [True: 86.8k, False: 1.71k] | Branch (1184:20): [True: 71.5k, False: 15.3k] ------------------ 1185| 17.0k| value->e = p; 1186| 19.0k| while (value->e != value->b && c_isspace (value->e[-1])) ------------------ | Branch (1186:14): [True: 11.1k, False: 7.86k] | Branch (1186:38): [True: 2.02k, False: 9.17k] ------------------ 1187| 2.02k| --value->e; 1188| 17.0k| if (*p == separator) ++p; ------------------ | Branch (1188:11): [True: 15.3k, False: 1.71k] ------------------ 1189| 17.0k| } 1190| 18.1k| *source = p; 1191| | 1192| 18.1k| param_type = modify_param_name (name); 1193| 18.1k| if (param_type != NOT_RFC2231) ------------------ | | 1051| 18.1k|#define NOT_RFC2231 0 ------------------ | Branch (1193:7): [True: 5.60k, False: 12.5k] ------------------ 1194| 5.60k| { 1195| 5.60k| if (param_type == RFC2231_ENCODING && is_url_encoded) ------------------ | | 1053| 11.2k|#define RFC2231_ENCODING 2 ------------------ | Branch (1195:11): [True: 4.62k, False: 975] | Branch (1195:45): [True: 0, False: 4.62k] ------------------ 1196| 0| *is_url_encoded = true; 1197| 5.60k| modify_param_value (value, param_type); 1198| 5.60k| } 1199| 18.1k| return true; 1200| 18.2k|} http_atotm: 4936| 3.35k|{ 4937| | /* NOTE: Solaris strptime man page claims that %n and %t match white 4938| | space, but that's not universally available. Instead, we simply 4939| | use ` ' to mean "skip all WS", which works under all strptime 4940| | implementations I've tested. */ 4941| | 4942| 3.35k| static const char *time_formats[] = { 4943| 3.35k| "%a, %d %b %Y %T", /* rfc1123: Thu, 29 Jan 1998 22:12:57 */ 4944| 3.35k| "%A, %d-%b-%y %T", /* rfc850: Thursday, 29-Jan-98 22:12:57 */ 4945| 3.35k| "%a %b %d %T %Y", /* asctime: Thu Jan 29 22:12:57 1998 */ 4946| 3.35k| "%a, %d-%b-%Y %T" /* cookies: Thu, 29-Jan-1998 22:12:57 4947| | (used in Set-Cookie, defined in the 4948| | Netscape cookie specification.) */ 4949| 3.35k| }; 4950| 3.35k| const char *oldlocale; 4951| 3.35k| char savedlocale[256]; 4952| 3.35k| size_t i; 4953| 3.35k| time_t ret = (time_t) -1; 4954| | 4955| | /* Solaris strptime fails to recognize English month names in 4956| | non-English locales, which we work around by temporarily setting 4957| | locale to C before invoking strptime. */ 4958| 3.35k| oldlocale = setlocale (LC_TIME, NULL); 4959| 3.35k| if (oldlocale) ------------------ | Branch (4959:7): [True: 3.35k, False: 0] ------------------ 4960| 3.35k| { 4961| 3.35k| size_t l = strlen (oldlocale) + 1; 4962| 3.35k| if (l >= sizeof savedlocale) ------------------ | Branch (4962:11): [True: 0, False: 3.35k] ------------------ 4963| 0| savedlocale[0] = '\0'; 4964| 3.35k| else 4965| 3.35k| memcpy (savedlocale, oldlocale, l); 4966| 3.35k| } 4967| 0| else savedlocale[0] = '\0'; 4968| | 4969| 3.35k| setlocale (LC_TIME, "C"); 4970| | 4971| 13.6k| for (i = 0; i < countof (time_formats); i++) ------------------ | | 175| 13.6k|#define countof(array) (sizeof (array) / sizeof ((array)[0])) ------------------ | Branch (4971:15): [True: 11.8k, False: 1.79k] ------------------ 4972| 11.8k| { 4973| 11.8k| struct tm t; 4974| | 4975| | /* Some versions of strptime use the existing contents of struct 4976| | tm to recalculate the date according to format. Zero it out 4977| | to prevent stack garbage from influencing strptime. */ 4978| 11.8k| xzero (t); ------------------ | | 178| 11.8k|#define xzero(x) memset (&(x), '\0', sizeof (x)) ------------------ 4979| | 4980| 11.8k| if (check_end (strptime (time_string, time_formats[i], &t))) ------------------ | Branch (4980:11): [True: 1.56k, False: 10.3k] ------------------ 4981| 1.56k| { 4982| 1.56k| ret = timegm (&t); 4983| 1.56k| break; 4984| 1.56k| } 4985| 11.8k| } 4986| | 4987| | /* Restore the previous locale. */ 4988| 3.35k| if (savedlocale[0]) ------------------ | Branch (4988:7): [True: 3.35k, False: 0] ------------------ 4989| 3.35k| setlocale (LC_TIME, savedlocale); 4990| | 4991| 3.35k| return ret; 4992| 3.35k|} http.c:modify_param_name: 1064| 18.1k|{ 1065| 18.1k| const char *delim1 = memchr (name->b, '*', name->e - name->b); 1066| 18.1k| const char *delim2 = memrchr (name->b, '*', name->e - name->b); 1067| | 1068| 18.1k| int result; 1069| | 1070| 18.1k| if (delim1 == NULL) ------------------ | Branch (1070:7): [True: 12.5k, False: 5.60k] ------------------ 1071| 12.5k| { 1072| 12.5k| result = NOT_RFC2231; ------------------ | | 1051| 12.5k|#define NOT_RFC2231 0 ------------------ 1073| 12.5k| } 1074| 5.60k| else if (delim1 == delim2) ------------------ | Branch (1074:12): [True: 4.60k, False: 996] ------------------ 1075| 4.60k| { 1076| 4.60k| if ((name->e - 1) == delim1) ------------------ | Branch (1076:11): [True: 3.63k, False: 975] ------------------ 1077| 3.63k| { 1078| 3.63k| result = RFC2231_ENCODING; ------------------ | | 1053| 3.63k|#define RFC2231_ENCODING 2 ------------------ 1079| 3.63k| } 1080| 975| else 1081| 975| { 1082| 975| result = RFC2231_NOENCODING; ------------------ | | 1052| 975|#define RFC2231_NOENCODING 1 ------------------ 1083| 975| } 1084| 4.60k| name->e = delim1; 1085| 4.60k| } 1086| 996| else 1087| 996| { 1088| 996| name->e = delim1; 1089| 996| result = RFC2231_ENCODING; ------------------ | | 1053| 996|#define RFC2231_ENCODING 2 ------------------ 1090| 996| } 1091| 18.1k| return result; 1092| 18.1k|} http.c:modify_param_value: 1100| 5.60k|{ 1101| 5.60k| if (encoding_type == RFC2231_ENCODING) ------------------ | | 1053| 5.60k|#define RFC2231_ENCODING 2 ------------------ | Branch (1101:7): [True: 4.62k, False: 975] ------------------ 1102| 4.62k| { 1103| 4.62k| const char *delim = memrchr (value->b, '\'', value->e - value->b); 1104| 4.62k| if (delim != NULL) ------------------ | Branch (1104:11): [True: 969, False: 3.65k] ------------------ 1105| 969| { 1106| 969| value->b = (delim+1); 1107| 969| } 1108| 4.62k| } 1109| 5.60k|} http.c:check_end: 4893| 11.8k|{ 4894| 11.8k| if (!p) ------------------ | Branch (4894:7): [True: 9.21k, False: 2.64k] ------------------ 4895| 9.21k| return false; 4896| 4.55k| while (c_isspace (*p)) ------------------ | Branch (4896:10): [True: 1.90k, False: 2.64k] ------------------ 4897| 1.90k| ++p; 4898| 2.64k| if (!*p ------------------ | Branch (4898:7): [True: 1.40k, False: 1.24k] ------------------ 4899| 2.64k| || (p[0] == 'G' && p[1] == 'M' && p[2] == 'T') ------------------ | Branch (4899:11): [True: 531, False: 711] | Branch (4899:26): [True: 300, False: 231] | Branch (4899:41): [True: 69, False: 231] ------------------ 4900| 2.64k| || ((p[0] == '+' || p[0] == '-') && c_isdigit (p[1]))) ------------------ | Branch (4900:12): [True: 216, False: 957] | Branch (4900:27): [True: 300, False: 657] | Branch (4900:43): [True: 90, False: 426] ------------------ 4901| 1.56k| return true; 4902| 1.08k| else 4903| 1.08k| return false; 4904| 2.64k|} logflush: 502| 3.60k|{ 503| 3.60k| FILE *fp = get_log_fp (); 504| 3.60k| FILE *warcfp = get_warc_log_fp (); 505| 3.60k| if (fp) ------------------ | Branch (505:7): [True: 3.60k, False: 0] ------------------ 506| 3.60k| { 507| |/* 2005-10-25 SMS. 508| | On VMS, flush only for a terminal. See note at FPUTS macro, above. 509| |*/ 510| |#ifdef __VMS 511| | if (isatty( fileno( fp))) 512| | { 513| | fflush (fp); 514| | } 515| |#else /* def __VMS */ 516| 3.60k| fflush (fp); 517| 3.60k|#endif /* def __VMS [else] */ 518| 3.60k| } 519| | 520| 3.60k| if (warcfp != NULL) ------------------ | Branch (520:7): [True: 3.60k, False: 0] ------------------ 521| 3.60k| fflush (warcfp); 522| | 523| 3.60k| needs_flushing = false; 524| 3.60k|} logprintf: 566| 3.60k|{ 567| 3.60k| va_list args; 568| 3.60k| struct logvprintf_state lpstate; 569| 3.60k| bool done; 570| 3.60k| int errno_saved = errno; 571| | 572| 3.60k| CHECK_VERBOSE (o); ------------------ | | 288| 3.60k| switch (x) \ | | ------------------ | | | Branch (288:11): [True: 0, False: 3.60k] | | ------------------ | | 289| 3.60k| { \ | | 290| 0| case LOG_PROGRESS: \ | | ------------------ | | | Branch (290:5): [True: 0, False: 3.60k] | | ------------------ | | 291| 0| if (!opt.show_progress) \ | | ------------------ | | | Branch (291:11): [True: 0, False: 0] | | ------------------ | | 292| 0| return; \ | | 293| 0| break; \ | | 294| 0| case LOG_ALWAYS: \ | | ------------------ | | | Branch (294:5): [True: 0, False: 3.60k] | | ------------------ | | 295| 0| break; \ | | 296| 3.60k| case LOG_NOTQUIET: \ | | ------------------ | | | Branch (296:5): [True: 3.60k, False: 0] | | ------------------ | | 297| 3.60k| if (opt.quiet) \ | | ------------------ | | | Branch (297:11): [True: 0, False: 3.60k] | | ------------------ | | 298| 3.60k| return; \ | | 299| 3.60k| break; \ | | 300| 3.60k| case LOG_NONVERBOSE: \ | | ------------------ | | | Branch (300:5): [True: 0, False: 3.60k] | | ------------------ | | 301| 0| if (opt.verbose || opt.quiet) \ | | ------------------ | | | Branch (301:11): [True: 0, False: 0] | | | Branch (301:26): [True: 0, False: 0] | | ------------------ | | 302| 0| return; \ | | 303| 0| break; \ | | 304| 0| case LOG_VERBOSE: \ | | ------------------ | | | Branch (304:5): [True: 0, False: 3.60k] | | ------------------ | | 305| 0| if (!opt.verbose) \ | | ------------------ | | | Branch (305:11): [True: 0, False: 0] | | ------------------ | | 306| 0| return; \ | | 307| 3.60k| } ------------------ 573| | 574| 3.60k| check_redirect_output (); 575| 3.60k| errno = errno_saved; 576| 3.60k| if (inhibit_logging) ------------------ | Branch (576:7): [True: 0, False: 3.60k] ------------------ 577| 0| return; 578| | 579| 3.60k| xzero (lpstate); ------------------ | | 178| 3.60k|#define xzero(x) memset (&(x), '\0', sizeof (x)) ------------------ 580| 3.60k| errno = 0; 581| 3.60k| do 582| 4.64k| { 583| 4.64k| va_start (args, fmt); 584| 4.64k| done = log_vprintf_internal (&lpstate, fmt, args); 585| 4.64k| va_end (args); 586| | 587| 4.64k| if (done && errno == EPIPE) ------------------ | Branch (587:11): [True: 3.60k, False: 1.03k] | Branch (587:19): [True: 0, False: 3.60k] ------------------ 588| 0| exit (WGET_EXIT_GENERIC_ERROR); ------------------ | | 321| 0|# define exit(status) exit_wget(status) ------------------ 589| 4.64k| } 590| 4.64k| while (!done); ------------------ | Branch (590:10): [True: 1.03k, False: 3.60k] ------------------ 591| | 592| 3.60k| errno = errno_saved; 593| 3.60k|} log.c:get_log_fp: 317| 8.25k|{ 318| 8.25k| if (inhibit_logging) ------------------ | Branch (318:7): [True: 0, False: 8.25k] ------------------ 319| 0| return NULL; 320| 8.25k| if (logfp) ------------------ | Branch (320:7): [True: 0, False: 8.25k] ------------------ 321| 0| return logfp; 322| 8.25k| return stderr; 323| 8.25k|} log.c:get_warc_log_fp: 342| 8.25k|{ 343| 8.25k| if (inhibit_logging) ------------------ | Branch (343:7): [True: 0, False: 8.25k] ------------------ 344| 0| return NULL; 345| 8.25k| if (warclogfp) ------------------ | Branch (345:7): [True: 0, False: 8.25k] ------------------ 346| 0| return warclogfp; 347| 8.25k| if (logfp) ------------------ | Branch (347:7): [True: 0, False: 8.25k] ------------------ 348| 0| return NULL; 349| 8.25k| return stderr; 350| 8.25k|} log.c:log_vprintf_internal: 422| 4.64k|{ 423| 4.64k| char smallmsg[128]; 424| 4.64k| char *write_ptr = smallmsg; 425| 4.64k| int available_size = sizeof (smallmsg); 426| 4.64k| int numwritten; 427| 4.64k| FILE *fp = get_log_fp (); 428| 4.64k| FILE *warcfp = get_warc_log_fp (); 429| | 430| 4.64k| if (fp == NULL) ------------------ | Branch (430:7): [True: 0, False: 4.64k] ------------------ 431| 0| return false; 432| | 433| 4.64k| if (!save_context_p && warcfp == NULL) ------------------ | Branch (433:7): [True: 4.64k, False: 0] | Branch (433:26): [True: 0, False: 4.64k] ------------------ 434| 0| { 435| | /* In the simple case just call vfprintf(), to avoid needless 436| | allocation and games with vsnprintf(). */ 437| 0| vfprintf (fp, fmt, args); 438| 0| goto flush; 439| 0| } 440| | 441| 4.64k| if (state->allocated != 0) ------------------ | Branch (441:7): [True: 1.03k, False: 3.60k] ------------------ 442| 1.03k| { 443| 1.03k| write_ptr = state->bigmsg; 444| 1.03k| available_size = state->allocated; 445| 1.03k| } 446| | 447| | /* The GNU coding standards advise not to rely on the return value 448| | of sprintf(). However, vsnprintf() is a relatively new function 449| | missing from legacy systems. Therefore I consider it safe to 450| | assume that its return value is meaningful. On the systems where 451| | vsnprintf() is not available, we use the implementation from 452| | snprintf.c which does return the correct value. */ 453| 4.64k| numwritten = vsnprintf (write_ptr, available_size, fmt, args); 454| | 455| | /* vsnprintf() will not step over the limit given by available_size. 456| | If it fails, it returns either -1 (older implementations) or the 457| | number of characters (not counting the terminating \0) that 458| | *would have* been written if there had been enough room (C99). 459| | In the former case, we double available_size and malloc to get a 460| | larger buffer, and try again. In the latter case, we use the 461| | returned information to build a buffer of the correct size. */ 462| | 463| 4.64k| if (numwritten == -1) ------------------ | Branch (463:7): [True: 0, False: 4.64k] ------------------ 464| 0| { 465| | /* Writing failed, and we don't know the needed size. Try 466| | again with doubled size. */ 467| 0| int newsize = available_size << 1; 468| 0| state->bigmsg = xrealloc (state->bigmsg, newsize); 469| 0| state->allocated = newsize; 470| 0| return false; 471| 0| } 472| 4.64k| else if (numwritten >= available_size) ------------------ | Branch (472:12): [True: 1.03k, False: 3.60k] ------------------ 473| 1.03k| { 474| | /* Writing failed, but we know exactly how much space we 475| | need. */ 476| 1.03k| int newsize = numwritten + 1; 477| 1.03k| state->bigmsg = xrealloc (state->bigmsg, newsize); 478| 1.03k| state->allocated = newsize; 479| 1.03k| return false; 480| 1.03k| } 481| | 482| | /* Writing succeeded. */ 483| 3.60k| if (save_context_p) ------------------ | Branch (483:7): [True: 0, False: 3.60k] ------------------ 484| 0| saved_append (write_ptr); 485| 3.60k| FPUTS (write_ptr, fp); ------------------ | | 55| 3.60k|# define FPUTS( s, f) fputs( (s), (f)) ------------------ 486| 3.60k| if (warcfp != NULL && warcfp != fp) ------------------ | Branch (486:7): [True: 3.60k, False: 0] | Branch (486:25): [True: 0, False: 3.60k] ------------------ 487| 0| FPUTS (write_ptr, warcfp); ------------------ | | 55| 0|# define FPUTS( s, f) fputs( (s), (f)) ------------------ 488| 3.60k| xfree (state->bigmsg); ------------------ | | 54| 3.60k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 489| | 490| 3.60k| flush: 491| 3.60k| if (flush_log_p) ------------------ | Branch (491:7): [True: 3.60k, False: 0] ------------------ 492| 3.60k| logflush (); 493| 0| else 494| 0| needs_flushing = true; 495| | 496| 3.60k| return true; 497| 3.60k|} log.c:check_redirect_output: 974| 3.60k|{ 975| 3.60k|#if !defined(WINDOWS) && !defined(__VMS) 976| | /* If it was redirected already to log file by SIGHUP, SIGUSR1 or -o parameter, 977| | * it was permanent. 978| | * If there was no SIGHUP or SIGUSR1 and shell is interactive 979| | * we check if process is fg or bg before every line is printed.*/ 980| 3.60k| if (!redirect_request_signal_name && shell_is_interactive && !opt.lfilename) ------------------ | Branch (980:7): [True: 3.60k, False: 0] | Branch (980:40): [True: 0, False: 3.60k] | Branch (980:64): [True: 0, False: 0] ------------------ 981| 0| { 982| 0| pid_t foreground_pgrp = tcgetpgrp (STDIN_FILENO); 983| | 984| 0| if (foreground_pgrp != -1 && foreground_pgrp != getpgrp () && !opt.quiet) ------------------ | Branch (984:11): [True: 0, False: 0] | Branch (984:36): [True: 0, False: 0] | Branch (984:69): [True: 0, False: 0] ------------------ 985| 0| { 986| | /* Process backgrounded */ 987| 0| redirect_output (true,NULL); 988| 0| } 989| 0| else 990| 0| { 991| | /* Process foregrounded */ 992| 0| redirect_output (false,NULL); 993| 0| } 994| 0| } 995| 3.60k|#endif /* !defined(WINDOWS) && !defined(__VMS) */ 996| 3.60k|} strdupdelim: 235| 10.6k|{ 236| 10.6k| if (beg && beg <= end) ------------------ | Branch (236:7): [True: 10.6k, False: 0] | Branch (236:14): [True: 10.6k, False: 0] ------------------ 237| 10.6k| { 238| 10.6k| char *res = xmalloc (end - beg + 1); 239| 10.6k| memcpy (res, beg, end - beg); 240| 10.6k| res[end - beg] = '\0'; 241| 10.6k| return res; 242| 10.6k| } 243| | 244| 0| return xstrdup(""); 245| 10.6k|} match_tail: 1168| 174|{ 1169| 174| int pos = (int) strlen (string) - (int) strlen (tail); 1170| | 1171| 174| if (pos < 0) ------------------ | Branch (1171:7): [True: 48, False: 126] ------------------ 1172| 48| return false; /* tail is longer than string. */ 1173| | 1174| 126| if (!fold_case) ------------------ | Branch (1174:7): [True: 0, False: 126] ------------------ 1175| 0| return !strcmp (string + pos, tail); 1176| 126| else 1177| 126| return !strcasecmp (string + pos, tail); 1178| 126|}