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|} 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: 86| 2.10k|{ 87| 2.10k|#ifdef HAVE_FMEMOPEN 88| 2.10k| FILE *fp; 89| 2.10k| struct fileinfo *fi; 90| | 91| 2.10k| if (size > 4096) // same as max_len = ... in .options file ------------------ | Branch (91:6): [True: 9, False: 2.09k] ------------------ 92| 9| return 0; 93| | 94| 2.09k| fp = fmemopen((void *) data, size, "r"); 95| 2.09k| if (!fp) return 0; ------------------ | Branch (95:6): [True: 0, False: 2.09k] ------------------ 96| | 97| 2.09k| CLOSE_STDERR ------------------ | | 30| 2.09k| int bak = dup(STDERR_FILENO); \ | | 31| 2.09k| int fd = open("/dev/null", O_WRONLY); \ | | 32| 2.09k| dup2(fd, STDERR_FILENO); \ | | 33| 2.09k| close(fd); ------------------ 98| | 99| 2.09k| do_jump = 1; 100| | 101| 2.09k| if (setjmp(jmpbuf)) 102| 0| goto done; 103| | 104| 2.09k| fi = ftp_parse_ls_fp(fp, ST_UNIX); 105| 2.09k| freefileinfo(fi); 106| 2.09k| rewind(fp); 107| | 108| 2.09k| fi = ftp_parse_ls_fp(fp, ST_VMS); 109| 2.09k| freefileinfo(fi); 110| 2.09k| rewind(fp); 111| | 112| 2.09k| fi = ftp_parse_ls_fp(fp, ST_WINNT); 113| 2.09k| freefileinfo(fi); 114| 2.09k| rewind(fp); 115| | 116| 2.09k| fi = ftp_parse_ls_fp(fp, ST_MACOS); 117| | 118| 2.09k|done: 119| 2.09k| freefileinfo(fi); 120| 2.09k| fclose(fp); 121| | 122| 2.09k| do_jump = 0; 123| | 124| 2.09k| RESTORE_STDERR ------------------ | | 36| 2.09k| dup2(bak, STDERR_FILENO); \ | | 37| 2.09k| close(bak); ------------------ 125| 2.09k|#endif 126| 2.09k| return 0; 127| 2.09k|} c_strcasecmp: 28| 779k|{ 29| 779k| register const unsigned char *p1 = (const unsigned char *) s1; 30| 779k| register const unsigned char *p2 = (const unsigned char *) s2; 31| 779k| unsigned char c1, c2; 32| | 33| 779k| if (p1 == p2) ------------------ | Branch (33:7): [True: 0, False: 779k] ------------------ 34| 0| return 0; 35| | 36| 779k| do 37| 872k| { 38| 872k| c1 = c_tolower (*p1); 39| 872k| c2 = c_tolower (*p2); 40| | 41| 872k| if (c1 == '\0') ------------------ | Branch (41:11): [True: 29.3k, False: 843k] ------------------ 42| 29.3k| break; 43| | 44| 843k| ++p1; 45| 843k| ++p2; 46| 843k| } 47| 843k| while (c1 == c2); ------------------ | Branch (47:10): [True: 92.7k, False: 750k] ------------------ 48| | 49| 779k| if (UCHAR_MAX <= INT_MAX) ------------------ | Branch (49:7): [Folded - Ignored] ------------------ 50| 779k| 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| 779k|} c_strncasecmp: 28| 58.1k|{ 29| 58.1k| register const unsigned char *p1 = (const unsigned char *) s1; 30| 58.1k| register const unsigned char *p2 = (const unsigned char *) s2; 31| 58.1k| unsigned char c1, c2; 32| | 33| 58.1k| if (p1 == p2 || n == 0) ------------------ | Branch (33:7): [True: 0, False: 58.1k] | Branch (33:19): [True: 0, False: 58.1k] ------------------ 34| 0| return 0; 35| | 36| 58.1k| do 37| 66.9k| { 38| 66.9k| c1 = c_tolower (*p1); 39| 66.9k| c2 = c_tolower (*p2); 40| | 41| 66.9k| if (--n == 0 || c1 == '\0') ------------------ | Branch (41:11): [True: 1.59k, False: 65.3k] | Branch (41:23): [True: 6.58k, False: 58.8k] ------------------ 42| 8.17k| break; 43| | 44| 58.8k| ++p1; 45| 58.8k| ++p2; 46| 58.8k| } 47| 58.8k| while (c1 == c2); ------------------ | Branch (47:10): [True: 8.82k, False: 49.9k] ------------------ 48| | 49| 58.1k| if (UCHAR_MAX <= INT_MAX) ------------------ | Branch (49:7): [Folded - Ignored] ------------------ 50| 58.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| 58.1k|} rpl_free: 33| 161k|{ 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| 161k| int err = errno; 48| 161k| free (p); 49| 161k| errno = err; 50| 161k|# endif 51| 161k|} mktime_internal: 324| 20.5k|{ 325| 20.5k| 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| 20.5k| 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| 20.5k| int sec = tp->tm_sec; 336| 20.5k| int min = tp->tm_min; 337| 20.5k| int hour = tp->tm_hour; 338| 20.5k| int mday = tp->tm_mday; 339| 20.5k| int mon = tp->tm_mon; 340| 20.5k| int year_requested = tp->tm_year; 341| 20.5k| int isdst = tp->tm_isdst; 342| | 343| | /* 1 if the previous probe was DST. */ 344| 20.5k| int dst2 = 0; 345| | 346| | /* Ensure that mon is in range, and set year accordingly. */ 347| 20.5k| int mon_remainder = mon % 12; 348| 20.5k| int negative_mon_remainder = mon_remainder < 0; 349| 20.5k| int mon_years = mon / 12 - negative_mon_remainder; 350| 20.5k| long_int lyear_requested = year_requested; 351| 20.5k| 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| 20.5k| int mon_yday = ((__mon_yday[leapyear (year)] 359| 20.5k| [mon_remainder + 12 * negative_mon_remainder]) 360| 20.5k| - 1); 361| 20.5k| long_int lmday = mday; 362| 20.5k| long_int yday = mon_yday + lmday; 363| | 364| 20.5k| mktime_offset_t off = *offset; 365| 20.5k| int negative_offset_guess; 366| | 367| 20.5k| int sec_requested = sec; 368| | 369| 20.5k| if (LEAP_SECONDS_POSSIBLE) ------------------ | | 41| 20.5k|# define LEAP_SECONDS_POSSIBLE 1 | | ------------------ | | | Branch (41:32): [Folded - Ignored] | | ------------------ ------------------ 370| 20.5k| { 371| | /* Handle out-of-range seconds specially, 372| | since ydhms_diff assumes every minute has 60 seconds. */ 373| 20.5k| if (sec < 0) ------------------ | Branch (373:11): [True: 0, False: 20.5k] ------------------ 374| 0| sec = 0; 375| 20.5k| if (59 < sec) ------------------ | Branch (375:11): [True: 323, False: 20.2k] ------------------ 376| 323| sec = 59; 377| 20.5k| } 378| | 379| | /* Invert CONVERT by probing. First assume the same offset as last 380| | time. */ 381| | 382| 20.5k| INT_SUBTRACT_WRAPV (0, off, &negative_offset_guess); ------------------ | | 301| 20.5k|#define INT_SUBTRACT_WRAPV(a, b, r) _GL_INT_SUBTRACT_WRAPV (a, b, r) | | ------------------ | | | | 148| 20.5k|# define _GL_INT_SUBTRACT_WRAPV(a, b, r) __builtin_sub_overflow (a, b, r) | | ------------------ ------------------ 383| 20.5k| long_int t0 = ydhms_diff (year, yday, hour, min, sec, 384| 20.5k| EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, ------------------ | | 157| 20.5k|#define EPOCH_YEAR 1970 ------------------ EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, ------------------ | | 158| 20.5k|#define TM_YEAR_BASE 1900 ------------------ 385| 20.5k| negative_offset_guess); 386| 20.5k| long_int t = t0, t1 = t0, t2 = t0; 387| | 388| | /* Repeatedly use the error to improve the guess. */ 389| | 390| 20.5k| while (true) 391| 22.8k| { 392| 22.8k| if (! ranged_convert (convert, &t, &tm)) ------------------ | Branch (392:11): [True: 0, False: 22.8k] ------------------ 393| 0| return -1; 394| 22.8k| long_int dt = tm_diff (year, yday, hour, min, sec, &tm); 395| 22.8k| if (dt == 0) ------------------ | Branch (395:11): [True: 20.0k, False: 2.78k] ------------------ 396| 20.0k| break; 397| | 398| 2.78k| if (t == t1 && t != t2 ------------------ | Branch (398:11): [True: 1.85k, False: 928] | Branch (398:22): [True: 0, False: 1.85k] ------------------ 399| 2.78k| && (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| 2.78k| remaining_probes--; 415| 2.78k| if (remaining_probes == 0) ------------------ | Branch (415:11): [True: 464, False: 2.32k] ------------------ 416| 464| { 417| 464| __set_errno (EOVERFLOW); ------------------ | | 46| 464|# define __set_errno(val) (errno = (val)) ------------------ 418| 464| return -1; 419| 464| } 420| | 421| 2.32k| t1 = t2, t2 = t, t += dt, dst2 = tm.tm_isdst != 0; 422| 2.32k| } 423| | 424| | /* We have a match. Check whether tm.tm_isdst has the requested 425| | value, if any. */ 426| 20.0k| if (isdst_differ (isdst, tm.tm_isdst)) ------------------ | Branch (426:7): [True: 0, False: 20.0k] ------------------ 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| 20.0k| 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| 20.0k| INT_SUBTRACT_WRAPV (t, t0, offset); ------------------ | | 301| 20.0k|#define INT_SUBTRACT_WRAPV(a, b, r) _GL_INT_SUBTRACT_WRAPV (a, b, r) | | ------------------ | | | | 148| 20.0k|# define _GL_INT_SUBTRACT_WRAPV(a, b, r) __builtin_sub_overflow (a, b, r) | | ------------------ ------------------ 507| 20.0k| INT_SUBTRACT_WRAPV (*offset, negative_offset_guess, offset); ------------------ | | 301| 20.0k|#define INT_SUBTRACT_WRAPV(a, b, r) _GL_INT_SUBTRACT_WRAPV (a, b, r) | | ------------------ | | | | 148| 20.0k|# define _GL_INT_SUBTRACT_WRAPV(a, b, r) __builtin_sub_overflow (a, b, r) | | ------------------ ------------------ 508| | 509| 20.0k| if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec) ------------------ | | 41| 40.1k|# define LEAP_SECONDS_POSSIBLE 1 | | ------------------ | | | Branch (41:32): [Folded - Ignored] | | ------------------ ------------------ | Branch (509:32): [True: 323, False: 19.7k] ------------------ 510| 323| { 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| 323| long_int sec_adjustment = sec == 0 && tm.tm_sec == 60; ------------------ | Branch (513:33): [True: 0, False: 323] | Branch (513:45): [True: 0, False: 0] ------------------ 514| 323| sec_adjustment -= sec; 515| 323| sec_adjustment += sec_requested; 516| 323| if (INT_ADD_WRAPV (t, sec_adjustment, &t) ------------------ | | 300| 323|#define INT_ADD_WRAPV(a, b, r) _GL_INT_ADD_WRAPV (a, b, r) | | ------------------ | | | | 147| 646|# define _GL_INT_ADD_WRAPV(a, b, r) __builtin_add_overflow (a, b, r) | | | | ------------------ | | | | | Branch (147:37): [True: 0, False: 323] | | | | ------------------ | | ------------------ ------------------ 517| 323| || ! (mktime_min <= t && t <= mktime_max)) ------------------ | Branch (517:10): [True: 323, False: 0] | Branch (517:29): [True: 323, False: 0] ------------------ 518| 0| { 519| 0| __set_errno (EOVERFLOW); ------------------ | | 46| 0|# define __set_errno(val) (errno = (val)) ------------------ 520| 0| return -1; 521| 0| } 522| 323| if (! convert_time (convert, t, &tm)) ------------------ | Branch (522:11): [True: 0, False: 323] ------------------ 523| 0| return -1; 524| 323| } 525| | 526| 20.0k| *tp = tm; 527| 20.0k| return t; 528| 20.0k|} rpl_mktime: 537| 20.5k|{ 538| | /* POSIX.1 8.1.1 requires that whenever mktime() is called, the 539| | time zone names contained in the external variable 'tzname' shall 540| | be set as if the tzset() function had been called. */ 541| 20.5k| __tzset (); ------------------ | | 102| 20.5k|# define __tzset() my_tzset () ------------------ 542| | 543| 20.5k|# if defined _LIBC || NEED_MKTIME_WORKING 544| 20.5k| static mktime_offset_t localtime_offset; 545| 20.5k| return __mktime_internal (tp, __localtime64_r, &localtime_offset); ------------------ | | 69| 20.5k|# define __mktime_internal mktime_internal ------------------ return __mktime_internal (tp, __localtime64_r, &localtime_offset); ------------------ | | 48| 20.5k|# define __localtime64_r __localtime_r | | ------------------ | | | | 67| 20.5k|# define __localtime_r localtime_r | | ------------------ ------------------ 546| |# else 547| |# undef mktime 548| | return mktime (tp); 549| |# endif 550| 20.5k|} mktime.c:leapyear: 164| 20.5k|{ 165| | /* Don't add YEAR to TM_YEAR_BASE, as that might overflow. 166| | Also, work even if YEAR is negative. */ 167| 20.5k| return 168| 20.5k| ((year & 3) == 0 ------------------ | Branch (168:6): [True: 2.61k, False: 17.9k] ------------------ 169| 20.5k| && (year % 100 != 0 ------------------ | Branch (169:10): [True: 2.19k, False: 427] ------------------ 170| 2.61k| || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3))); ------------------ | | 158| 427|#define TM_YEAR_BASE 1900 ------------------ | Branch (170:6): [True: 244, False: 183] ------------------ 171| 20.5k|} mktime.c:ydhms_diff: 207| 43.3k|{ 208| 43.3k| verify (-1 / 2 == 0); ------------------ | | 322| 43.3k|# define verify(R) _GL_VERIFY (R, "verify (" #R ")", -) | | ------------------ | | | | 213| 43.3k|# 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| 43.3k| int a4 = shr (year1, 2) + shr (TM_YEAR_BASE, 2) - ! (year1 & 3); ------------------ | | 158| 43.3k|#define TM_YEAR_BASE 1900 ------------------ 213| 43.3k| int b4 = shr (year0, 2) + shr (TM_YEAR_BASE, 2) - ! (year0 & 3); ------------------ | | 158| 43.3k|#define TM_YEAR_BASE 1900 ------------------ 214| 43.3k| int a100 = (a4 + (a4 < 0)) / 25 - (a4 < 0); 215| 43.3k| int b100 = (b4 + (b4 < 0)) / 25 - (b4 < 0); 216| 43.3k| int a400 = shr (a100, 2); 217| 43.3k| int b400 = shr (b100, 2); 218| 43.3k| int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400); 219| | 220| | /* Compute the desired time without overflowing. */ 221| 43.3k| long_int years = year1 - year0; 222| 43.3k| long_int days = 365 * years + yday1 - yday0 + intervening_leap_days; 223| 43.3k| long_int hours = 24 * days + hour1 - hour0; 224| 43.3k| long_int minutes = 60 * hours + min1 - min0; 225| 43.3k| long_int seconds = 60 * minutes + sec1 - sec0; 226| 43.3k| return seconds; 227| 43.3k|} mktime.c:shr: 140| 577k|{ 141| 577k| long_int one = 1; 142| 577k| return (-one >> 1 == -1 ------------------ | Branch (142:11): [True: 577k, False: 0] ------------------ 143| 577k| ? a >> b 144| 577k| : (a + (a < 0)) / (one << b) - (a < 0)); 145| 577k|} mktime.c:ranged_convert: 272| 22.8k|{ 273| 22.8k| long_int t1 = (*t < mktime_min ? mktime_min ------------------ | Branch (273:18): [True: 0, False: 22.8k] ------------------ 274| 22.8k| : *t <= mktime_max ? *t : mktime_max); ------------------ | Branch (274:6): [True: 22.8k, False: 0] ------------------ 275| 22.8k| struct tm *r = convert_time (convert, t1, tp); 276| 22.8k| if (r) ------------------ | Branch (276:7): [True: 20.0k, False: 2.78k] ------------------ 277| 20.0k| { 278| 20.0k| *t = t1; 279| 20.0k| return r; 280| 20.0k| } 281| 2.78k| if (errno != EOVERFLOW) ------------------ | Branch (281:7): [True: 0, False: 2.78k] ------------------ 282| 0| return NULL; 283| | 284| 2.78k| long_int bad = t1; 285| 2.78k| long_int ok = 0; 286| 2.78k| 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| 2.78k| while (true) 292| 158k| { 293| 158k| long_int mid = long_int_avg (ok, bad); 294| 158k| if (mid == ok || mid == bad) ------------------ | Branch (294:11): [True: 2.13k, False: 156k] | Branch (294:24): [True: 648, False: 155k] ------------------ 295| 2.78k| break; 296| 155k| if (convert_time (convert, mid, tp)) ------------------ | Branch (296:11): [True: 94.3k, False: 61.3k] ------------------ 297| 94.3k| ok = mid, oktm = *tp; 298| 61.3k| else if (errno != EOVERFLOW) ------------------ | Branch (298:16): [True: 0, False: 61.3k] ------------------ 299| 0| return NULL; 300| 61.3k| else 301| 61.3k| bad = mid; 302| 155k| } 303| | 304| 2.78k| if (oktm.tm_sec < 0) ------------------ | Branch (304:7): [True: 0, False: 2.78k] ------------------ 305| 0| return NULL; 306| 2.78k| *t = ok; 307| 2.78k| *tp = oktm; 308| 2.78k| return tp; 309| 2.78k|} mktime.c:long_int_avg: 233| 158k|{ 234| 158k| return shr (a, 1) + shr (b, 1) + ((a | b) & 1); 235| 158k|} mktime.c:tm_diff: 247| 22.8k|{ 248| 22.8k| return ydhms_diff (year, yday, hour, min, sec, 249| 22.8k| tp->tm_year, tp->tm_yday, 250| 22.8k| tp->tm_hour, tp->tm_min, tp->tm_sec); 251| 22.8k|} mktime.c:isdst_differ: 190| 20.0k|{ 191| 20.0k| return (!a != !b) && (0 <= a) && (0 <= b); ------------------ | Branch (191:10): [True: 9.80k, False: 10.2k] | Branch (191:24): [True: 0, False: 9.80k] | Branch (191:36): [True: 0, False: 0] ------------------ 192| 20.0k|} mktime.c:convert_time: 259| 178k|{ 260| 178k| __time64_t x = t; ------------------ | | 46| 178k|# define __time64_t time_t ------------------ 261| 178k| return convert (&x, tm); 262| 178k|} mktime.c:my_tzset: 70| 20.5k|{ 71| |# if NEED_MKTIME_WINDOWS 72| | /* Rectify the value of the environment variable TZ. 73| | There are four possible kinds of such values: 74| | - Traditional US time zone names, e.g. "PST8PDT". Syntax: see 75| | 76| | - Time zone names based on geography, that contain one or more 77| | slashes, e.g. "Europe/Moscow". 78| | - Time zone names based on geography, without slashes, e.g. 79| | "Singapore". 80| | - Time zone names that contain explicit DST rules. Syntax: see 81| | 82| | The Microsoft CRT understands only the first kind. It produces incorrect 83| | results if the value of TZ is of the other kinds. 84| | But in a Cygwin environment, /etc/profile.d/tzset.sh sets TZ to a value 85| | of the second kind for most geographies, or of the first kind in a few 86| | other geographies. If it is of the second kind, neutralize it. For the 87| | Microsoft CRT, an absent or empty TZ means the time zone that the user 88| | has set in the Windows Control Panel. 89| | If the value of TZ is of the third or fourth kind -- Cygwin programs 90| | understand these syntaxes as well --, it does not matter whether we 91| | neutralize it or not, since these values occur only when a Cygwin user 92| | has set TZ explicitly; this case is 1. rare and 2. under the user's 93| | responsibility. */ 94| | const char *tz = getenv ("TZ"); 95| | if (tz != NULL && strchr (tz, '/') != NULL) 96| | _putenv ("TZ="); 97| |# else 98| 20.5k| tzset (); 99| 20.5k|# endif 100| 20.5k|} xmalloc: 44| 48.9k|{ 45| 48.9k| return nonnull (malloc (s)); 46| 48.9k|} xmemdup: 313| 18.7k|{ 314| 18.7k| return memcpy (xmalloc (s), p, s); 315| 18.7k|} xstrdup: 338| 18.7k|{ 339| 18.7k| return xmemdup (string, strlen (string) + 1); 340| 18.7k|} xmalloc.c:nonnull: 34| 48.9k|{ 35| 48.9k| if (!p) ------------------ | Branch (35:7): [True: 0, False: 48.9k] ------------------ 36| 0| xalloc_die (); 37| 48.9k| return p; 38| 48.9k|} c_isdigit: 232| 53.9k|{ 233| 53.9k| switch (c) 234| 53.9k| { 235| 27.9k| _C_CTYPE_DIGIT: ------------------ | | 133| 13.0k| case '0': case '1': case '2': case '3': \ | | ------------------ | | | Branch (133:4): [True: 4.64k, False: 49.3k] | | | Branch (133:14): [True: 2.73k, False: 51.2k] | | | Branch (133:24): [True: 2.64k, False: 51.3k] | | | Branch (133:34): [True: 3.06k, False: 50.9k] | | ------------------ | | 134| 22.3k| case '4': case '5': case '6': case '7': \ | | ------------------ | | | Branch (134:4): [True: 4.84k, False: 49.1k] | | | Branch (134:14): [True: 1.92k, False: 52.0k] | | | Branch (134:24): [True: 1.00k, False: 52.9k] | | | Branch (134:34): [True: 1.44k, False: 52.5k] | | ------------------ | | 135| 27.9k| case '8': case '9' | | ------------------ | | | Branch (135:4): [True: 4.32k, False: 49.6k] | | ------------------ ------------------ 236| 27.9k| return true; 237| 25.9k| default: ------------------ | Branch (237:5): [True: 25.9k, False: 27.9k] ------------------ 238| 25.9k| return false; 239| 53.9k| } 240| 53.9k|} c_tolower: 336| 1.87M|{ 337| 1.87M| switch (c) 338| 1.87M| { 339| 1.00M| _C_CTYPE_UPPER: ------------------ | | 146| 0|#define _C_CTYPE_UPPER _C_CTYPE_LOWER_N ('A' - 'a') | | ------------------ | | | | 120| 455k| _C_CTYPE_LOWER_A_THRU_F_N(N): \ | | | | ------------------ | | | | | | 117| 370k| case 'a' + (N): case 'b' + (N): case 'c' + (N): case 'd' + (N): \ | | | | | | ------------------ | | | | | | | Branch (117:4): [True: 299k, False: 1.58M] | | | | | | | Branch (117:20): [True: 84, False: 1.87M] | | | | | | | Branch (117:36): [True: 25, False: 1.87M] | | | | | | | Branch (117:52): [True: 71.0k, False: 1.80M] | | | | | | ------------------ | | | | | | 118| 455k| case 'e' + (N): case 'f' + (N) | | | | | | ------------------ | | | | | | | Branch (118:4): [True: 8.46k, False: 1.87M] | | | | | | ------------------ | | | | ------------------ | | | | | Branch (120:4): [True: 76.4k, False: 1.80M] | | | | ------------------ | | | | 121| 687k| case 'g' + (N): case 'h' + (N): case 'i' + (N): case 'j' + (N): \ | | | | ------------------ | | | | | Branch (121:4): [True: 342, False: 1.87M] | | | | | Branch (121:20): [True: 66, False: 1.87M] | | | | | Branch (121:36): [True: 2.05k, False: 1.87M] | | | | | Branch (121:52): [True: 229k, False: 1.64M] | | | | ------------------ | | | | 122| 889k| case 'k' + (N): case 'l' + (N): case 'm' + (N): case 'n' + (N): \ | | | | ------------------ | | | | | Branch (122:4): [True: 124, False: 1.87M] | | | | | Branch (122:20): [True: 478, False: 1.87M] | | | | | Branch (122:36): [True: 147k, False: 1.73M] | | | | | Branch (122:52): [True: 53.9k, False: 1.82M] | | | | ------------------ | | | | 123| 945k| case 'o' + (N): case 'p' + (N): case 'q' + (N): case 'r' + (N): \ | | | | ------------------ | | | | | Branch (123:4): [True: 54.0k, False: 1.82M] | | | | | Branch (123:20): [True: 83, False: 1.87M] | | | | | Branch (123:36): [True: 410, False: 1.87M] | | | | | Branch (123:52): [True: 1.66k, False: 1.87M] | | | | ------------------ | | | | 124| 1.00M| case 's' + (N): case 't' + (N): case 'u' + (N): case 'v' + (N): \ | | | | ------------------ | | | | | Branch (124:4): [True: 53.6k, False: 1.82M] | | | | | Branch (124:20): [True: 1.75k, False: 1.87M] | | | | | Branch (124:36): [True: 814, False: 1.87M] | | | | | Branch (124:52): [True: 262, False: 1.87M] | | | | ------------------ | | | | 125| 1.00M| case 'w' + (N): case 'x' + (N): case 'y' + (N): case 'z' + (N) | | | | ------------------ | | | | | Branch (125:4): [True: 180, False: 1.87M] | | | | | Branch (125:20): [True: 67, False: 1.87M] | | | | | Branch (125:36): [True: 138, False: 1.87M] | | | | ------------------ | | ------------------ ------------------ 340| 1.00M| return c - 'A' + 'a'; 341| 877k| default: ------------------ | Branch (341:5): [True: 877k, False: 1.00M] ------------------ 342| 877k| return c; 343| 1.87M| } 344| 1.87M|} ftp_parse_ls_fp: 1022| 8.37k|{ 1023| 8.37k| switch (system_type) 1024| 8.37k| { 1025| 2.09k| case ST_UNIX: ------------------ | Branch (1025:5): [True: 2.09k, False: 6.28k] ------------------ 1026| 2.09k| return ftp_parse_unix_ls (fp, 0); 1027| 2.09k| case ST_WINNT: ------------------ | Branch (1027:5): [True: 2.09k, False: 6.28k] ------------------ 1028| 2.09k| { 1029| | /* Detect whether the listing is simulating the UNIX format */ 1030| 2.09k| int c = fgetc(fp); 1031| 2.09k| rewind(fp); 1032| | 1033| | /* If the first character of the file is '0'-'9', it's WINNT 1034| | format. */ 1035| 2.09k| if (c >= '0' && c <='9') ------------------ | Branch (1035:13): [True: 1.75k, False: 335] | Branch (1035:25): [True: 874, False: 885] ------------------ 1036| 874| return ftp_parse_winnt_ls (fp); 1037| 1.22k| else 1038| 1.22k| return ftp_parse_unix_ls (fp, 1); 1039| 2.09k| } 1040| 2.09k| case ST_VMS: ------------------ | Branch (1040:5): [True: 2.09k, False: 6.28k] ------------------ 1041| 2.09k| return ftp_parse_vms_ls (fp); 1042| 2.09k| case ST_MACOS: ------------------ | Branch (1042:5): [True: 2.09k, False: 6.28k] ------------------ 1043| 2.09k| return ftp_parse_unix_ls (fp, 1); 1044| 0| default: ------------------ | Branch (1044:5): [True: 0, False: 8.37k] ------------------ 1045| 0| logprintf (LOG_NOTQUIET, _("\ ------------------ | | 64| 0|#define _(STRING) gettext(STRING) ------------------ 1046| 0|Unsupported listing type, trying Unix listing parser.\n")); 1047| 0| return ftp_parse_unix_ls (fp, 0); 1048| 8.37k| } 1049| 8.37k|} ftp-ls.c:ftp_parse_unix_ls: 95| 5.40k|{ 96| 5.40k| static const char *months[] = { 97| 5.40k| "Jan", "Feb", "Mar", "Apr", "May", "Jun", 98| 5.40k| "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" 99| 5.40k| }; 100| 5.40k| int next, len, i, error, ignore; 101| 5.40k| int year, month, day; /* for time analysis */ 102| 5.40k| int hour, min, sec, ptype; 103| 5.40k| struct tm timestruct, *tnow; 104| 5.40k| time_t timenow; 105| 5.40k| size_t bufsize = 0; 106| | 107| 5.40k| char *line = NULL, *tok, *ptok; /* tokenizer */ 108| 5.40k| struct fileinfo *dir, *l, cur; /* list creation */ 109| | 110| 5.40k| dir = l = NULL; 111| | 112| | /* Line loop to end of file: */ 113| 57.5k| while ((len = getline (&line, &bufsize, fp)) > 0) ------------------ | Branch (113:10): [True: 52.1k, False: 5.40k] ------------------ 114| 52.1k| { 115| 52.1k| len = clean_line (line, len); 116| | /* Skip if total... */ 117| 52.1k| if (!c_strncasecmp (line, "total", 5)) ------------------ | Branch (117:11): [True: 806, False: 51.3k] ------------------ 118| 806| continue; 119| | /* Get the first token (permissions). */ 120| 51.3k| tok = strtok (line, " "); 121| 51.3k| if (!tok) ------------------ | Branch (121:11): [True: 6.67k, False: 44.6k] ------------------ 122| 6.67k| continue; 123| | 124| 44.6k| cur.name = NULL; 125| 44.6k| cur.linkto = NULL; 126| | 127| | /* Decide whether we deal with a file or a directory. */ 128| 44.6k| switch (*tok) 129| 44.6k| { 130| 5.97k| case '-': ------------------ | Branch (130:9): [True: 5.97k, False: 38.7k] ------------------ 131| 5.97k| cur.type = FT_PLAINFILE; 132| 5.97k| DEBUGP (("PLAINFILE; ")); ------------------ | | 129| 5.97k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 5.97k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 5.97k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 5.97k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 133| 5.97k| break; 134| 5.23k| case 'd': ------------------ | Branch (134:9): [True: 5.23k, False: 39.4k] ------------------ 135| 5.23k| cur.type = FT_DIRECTORY; 136| 5.23k| DEBUGP (("DIRECTORY; ")); ------------------ | | 129| 5.23k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 5.23k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 5.23k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 5.23k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 137| 5.23k| break; 138| 5.41k| case 'l': ------------------ | Branch (138:9): [True: 5.41k, False: 39.2k] ------------------ 139| 5.41k| cur.type = FT_SYMLINK; 140| 5.41k| DEBUGP (("SYMLINK; ")); ------------------ | | 129| 5.41k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 5.41k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 5.41k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 5.41k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 141| 5.41k| break; 142| 28.0k| default: ------------------ | Branch (142:9): [True: 28.0k, False: 16.6k] ------------------ 143| 28.0k| cur.type = FT_UNKNOWN; 144| 28.0k| DEBUGP (("UNKNOWN; ")); ------------------ | | 129| 28.0k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 28.0k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 28.0k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 28.0k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 145| 28.0k| break; 146| 44.6k| } 147| | 148| 44.6k| if (ignore_perms) ------------------ | Branch (148:11): [True: 28.8k, False: 15.7k] ------------------ 149| 28.8k| { 150| 28.8k| switch (cur.type) 151| 28.8k| { 152| 3.95k| case FT_PLAINFILE: ------------------ | Branch (152:13): [True: 3.95k, False: 24.9k] ------------------ 153| 3.95k| cur.perms = 0644; 154| 3.95k| break; 155| 3.44k| case FT_DIRECTORY: ------------------ | Branch (155:13): [True: 3.44k, False: 25.4k] ------------------ 156| 3.44k| cur.perms = 0755; 157| 3.44k| break; 158| 21.4k| default: ------------------ | Branch (158:13): [True: 21.4k, False: 7.40k] ------------------ 159| | /*cur.perms = 1023;*/ /* #### What is this? --hniksic */ 160| 21.4k| cur.perms = 0644; 161| 28.8k| } 162| 28.8k| DEBUGP (("implicit perms %0o; ", (unsigned) cur.perms)); ------------------ | | 129| 28.8k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 28.8k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 28.8k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 28.8k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 163| 28.8k| } 164| 15.7k| else 165| 15.7k| { 166| 15.7k| cur.perms = symperms (tok + 1); 167| 15.7k| DEBUGP (("perms %0o; ", (unsigned) cur.perms)); ------------------ | | 129| 15.7k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 15.7k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 15.7k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 15.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 168| 15.7k| } 169| | 170| 44.6k| error = ignore = 0; /* Erroneous and ignoring entries are 171| | treated equally for now. */ 172| 44.6k| year = hour = min = sec = 0; /* Silence the compiler. */ 173| 44.6k| month = day = 0; 174| 44.6k| ptype = TT_DAY; 175| 44.6k| next = -1; 176| | /* While there are tokens on the line, parse them. Next is the 177| | number of tokens left until the filename. 178| | 179| | Use the month-name token as the "anchor" (the place where the 180| | position wrt the file name is "known"). When a month name is 181| | encountered, `next' is set to 5. Also, the preceding 182| | characters are parsed to get the file size. 183| | 184| | This tactic is quite dubious when it comes to 185| | internationalization issues (non-English month names), but it 186| | works for now. */ 187| 44.6k| tok = line; 188| 152k| while (ptok = tok, ------------------ | Branch (188:14): [True: 121k, False: 31.1k] ------------------ 189| 152k| (tok = strtok (NULL, " ")) != NULL) 190| 121k| { 191| 121k| --next; 192| 121k| if (next < 0) /* a month name was not encountered */ ------------------ | Branch (192:15): [True: 73.1k, False: 48.0k] ------------------ 193| 73.1k| { 194| 832k| for (i = 0; i < 12; i++) ------------------ | Branch (194:27): [True: 779k, False: 52.1k] ------------------ 195| 779k| if (!c_strcasecmp (tok, months[i])) ------------------ | Branch (195:21): [True: 20.9k, False: 759k] ------------------ 196| 20.9k| break; 197| | /* If we got a month, it means the token before it is the 198| | size, and the filename is three tokens away. */ 199| 73.1k| if (i != 12) ------------------ | Branch (199:19): [True: 20.9k, False: 52.1k] ------------------ 200| 20.9k| { 201| 20.9k| wgint size; 202| | 203| | /* Parse the previous token with str_to_wgint. */ 204| 20.9k| if (ptok == line) ------------------ | Branch (204:23): [True: 960, False: 19.9k] ------------------ 205| 960| { 206| | /* Something has gone wrong during parsing. */ 207| 960| error = 1; 208| 960| break; 209| 960| } 210| 19.9k| errno = 0; 211| 19.9k| size = str_to_wgint (ptok, NULL, 10); ------------------ | | 147| 19.9k|#define str_to_wgint strtoll ------------------ 212| 19.9k| if (size == WGINT_MAX && errno == ERANGE) ------------------ | | 145| 39.9k|#define WGINT_MAX INT64_MAX ------------------ | Branch (212:23): [True: 406, False: 19.5k] | Branch (212:44): [True: 206, False: 200] ------------------ 213| | /* Out of range -- ignore the size. #### Should 214| | we refuse to start the download. */ 215| 206| cur.size = 0; 216| 19.7k| else 217| 19.7k| cur.size = size; 218| 19.9k| DEBUGP (("size: %s; ", number_to_static_string(cur.size))); ------------------ | | 129| 19.9k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 19.9k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 19.9k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 19.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 219| | 220| 19.9k| month = i; 221| 19.9k| next = 5; 222| 19.9k| DEBUGP (("month: %s; ", months[month])); ------------------ | | 129| 19.9k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 19.9k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 19.9k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 19.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 223| 19.9k| } 224| 73.1k| } 225| 48.0k| else if (next == 4) /* days */ ------------------ | Branch (225:20): [True: 18.5k, False: 29.5k] ------------------ 226| 18.5k| { 227| 18.5k| if (tok[1]) /* two-digit... */ ------------------ | Branch (227:19): [True: 939, False: 17.5k] ------------------ 228| 939| day = 10 * (*tok - '0') + tok[1] - '0'; 229| 17.5k| else /* ...or one-digit */ 230| 17.5k| day = *tok - '0'; 231| 18.5k| DEBUGP (("day: %d; ", day)); ------------------ | | 129| 18.5k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 18.5k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 18.5k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 18.5k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 232| 18.5k| } 233| 29.5k| else if (next == 3) ------------------ | Branch (233:20): [True: 17.0k, False: 12.5k] ------------------ 234| 17.0k| { 235| | /* This ought to be either the time, or the year. Let's 236| | be flexible! 237| | 238| | If we have a number x, it's a year. If we have x:y, 239| | it's hours and minutes. If we have x:y:z, z are 240| | seconds. */ 241| 17.0k| year = 0; 242| 17.0k| min = hour = sec = 0; 243| | /* We must deal with digits. */ 244| 17.0k| if (c_isdigit (*tok)) ------------------ | Branch (244:19): [True: 8.65k, False: 8.40k] ------------------ 245| 8.65k| { 246| | /* Suppose it's year. Limit to year 99999 to avoid integer overflow. */ 247| 21.3k| for (; c_isdigit (*tok) && year <= 99999; tok++) ------------------ | Branch (247:26): [True: 12.7k, False: 8.63k] | Branch (247:46): [True: 12.7k, False: 16] ------------------ 248| 12.7k| year = (*tok - '0') + 10 * year; 249| 8.65k| if (*tok == ':') ------------------ | Branch (249:23): [True: 3.05k, False: 5.59k] ------------------ 250| 3.05k| { 251| 3.05k| int n; 252| | /* This means these were hours! */ 253| 3.05k| hour = year; 254| 3.05k| year = 0; 255| 3.05k| ptype = TT_HOUR_MIN; 256| 3.05k| ++tok; 257| | /* Get the minutes... */ 258| 4.42k| for (n = 0; c_isdigit (*tok) && n < 2; tok++, n++) ------------------ | Branch (258:35): [True: 1.60k, False: 2.82k] | Branch (258:55): [True: 1.36k, False: 235] ------------------ 259| 1.36k| min = (*tok - '0') + 10 * min; 260| 3.05k| if (*tok == ':') ------------------ | Branch (260:27): [True: 1.68k, False: 1.37k] ------------------ 261| 1.68k| { 262| | /* ...and the seconds. */ 263| 1.68k| ++tok; 264| 3.55k| for (n = 0; c_isdigit (*tok) && n < 2; tok++, n++) ------------------ | Branch (264:39): [True: 2.20k, False: 1.34k] | Branch (264:59): [True: 1.86k, False: 339] ------------------ 265| 1.86k| sec = (*tok - '0') + 10 * sec; 266| 1.68k| } 267| 3.05k| } 268| 8.65k| } 269| 17.0k| if (year) ------------------ | Branch (269:19): [True: 4.93k, False: 12.1k] ------------------ 270| 4.93k| DEBUGP (("year: %d (no tm); ", year)); ------------------ | | 129| 4.93k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 4.93k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 4.93k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 4.93k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 271| 12.1k| else 272| 12.1k| DEBUGP (("time: %02d:%02d:%02d (no yr); ", hour, min, sec)); ------------------ | | 129| 12.1k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 12.1k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 12.1k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 12.1k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 273| 17.0k| } 274| 12.5k| else if (next == 2) /* The file name */ ------------------ | Branch (274:20): [True: 12.5k, False: 0] ------------------ 275| 12.5k| { 276| 12.5k| int fnlen; 277| 12.5k| char *p; 278| | 279| | /* Since the file name may contain a SPC, it is possible 280| | for strtok to handle it wrong. */ 281| 12.5k| fnlen = strlen (tok); 282| 12.5k| if (fnlen < len - (tok - line)) ------------------ | Branch (282:19): [True: 2.36k, False: 10.1k] ------------------ 283| 2.36k| { 284| | /* So we have a SPC in the file name. Restore the 285| | original. */ 286| 2.36k| tok[fnlen] = ' '; 287| | /* If the file is a symbolic link, it should have a 288| | ` -> ' somewhere. */ 289| 2.36k| if (cur.type == FT_SYMLINK) ------------------ | Branch (289:23): [True: 1.42k, False: 940] ------------------ 290| 1.42k| { 291| 1.42k| p = strstr (tok, " -> "); 292| 1.42k| if (!p) ------------------ | Branch (292:27): [True: 713, False: 713] ------------------ 293| 713| { 294| 713| error = 1; 295| 713| break; 296| 713| } 297| 713| cur.linkto = xstrdup (p + 4); 298| 713| DEBUGP (("link to: %s\n", cur.linkto)); ------------------ | | 129| 713|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 713|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 713|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 713] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 299| | /* And separate it from the file name. */ 300| 713| *p = '\0'; 301| 713| } 302| 2.36k| } 303| | /* If we have the filename, add it to the list of files or 304| | directories. */ 305| | /* "." and ".." are an exception! */ 306| 11.8k| if (!strcmp (tok, ".") || !strcmp (tok, "..")) ------------------ | Branch (306:19): [True: 713, False: 11.1k] | Branch (306:41): [True: 711, False: 10.3k] ------------------ 307| 1.42k| { 308| 1.42k| DEBUGP (("\nIgnoring `.' and `..'; ")); ------------------ | | 129| 1.42k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 1.42k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 1.42k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 1.42k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 309| 1.42k| ignore = 1; 310| 1.42k| break; 311| 1.42k| } 312| | /* Some FTP sites choose to have ls -F as their default 313| | LIST output, which marks the symlinks with a trailing 314| | `@', directory names with a trailing `/' and 315| | executables with a trailing `*'. This is no problem 316| | unless encountering a symbolic link ending with `@', 317| | or an executable ending with `*' on a server without 318| | default -F output. I believe these cases are very 319| | rare. */ 320| 10.3k| fnlen = strlen (tok); /* re-calculate `fnlen' */ 321| 10.3k| cur.name = xmalloc (fnlen + 1); 322| 10.3k| memcpy (cur.name, tok, fnlen + 1); 323| 10.3k| if (fnlen) ------------------ | Branch (323:19): [True: 10.3k, False: 0] ------------------ 324| 10.3k| { 325| 10.3k| if (cur.type == FT_DIRECTORY && cur.name[fnlen - 1] == '/') ------------------ | Branch (325:23): [True: 3.00k, False: 7.38k] | Branch (325:51): [True: 1.58k, False: 1.42k] ------------------ 326| 1.58k| { 327| 1.58k| cur.name[fnlen - 1] = '\0'; 328| 1.58k| DEBUGP (("trailing `/' on dir.\n")); ------------------ | | 129| 1.58k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 1.58k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 1.58k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 1.58k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 329| 1.58k| } 330| 8.81k| else if (cur.type == FT_SYMLINK && cur.name[fnlen - 1] == '@') ------------------ | Branch (330:28): [True: 2.16k, False: 6.65k] | Branch (330:54): [True: 713, False: 1.45k] ------------------ 331| 713| { 332| 713| cur.name[fnlen - 1] = '\0'; 333| 713| DEBUGP (("trailing `@' on link.\n")); ------------------ | | 129| 713|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 713|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 713|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 713] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 334| 713| } 335| 8.10k| else if (cur.type == FT_PLAINFILE ------------------ | Branch (335:28): [True: 2.98k, False: 5.11k] ------------------ 336| 8.10k| && (cur.perms & 0111) ------------------ | Branch (336:31): [True: 400, False: 2.58k] ------------------ 337| 8.10k| && cur.name[fnlen - 1] == '*') ------------------ | Branch (337:31): [True: 194, False: 206] ------------------ 338| 194| { 339| 194| cur.name[fnlen - 1] = '\0'; 340| 194| DEBUGP (("trailing `*' on exec.\n")); ------------------ | | 129| 194|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 194|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 194|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 194] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 341| 194| } 342| 10.3k| } /* if (fnlen) */ 343| 0| else 344| 0| error = 1; 345| 10.3k| break; 346| 11.8k| } 347| 0| else 348| 0| abort (); 349| 121k| } /* while */ 350| | 351| 44.6k| if (!cur.name || (cur.type == FT_SYMLINK && !cur.linkto)) ------------------ | Branch (351:11): [True: 34.2k, False: 10.3k] | Branch (351:25): [True: 2.16k, False: 8.23k] | Branch (351:51): [True: 1.45k, False: 713] ------------------ 352| 35.7k| error = 1; 353| | 354| 44.6k| DEBUGP (("%s\n", cur.name ? cur.name : "")); ------------------ | | 129| 44.6k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 44.6k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 44.6k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 44.6k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:54): [True: 0, False: 0] | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 355| | 356| 44.6k| if (error || ignore) ------------------ | Branch (356:11): [True: 35.7k, False: 8.94k] | Branch (356:20): [True: 0, False: 8.94k] ------------------ 357| 35.7k| { 358| 35.7k| DEBUGP (("Skipping.\n")); ------------------ | | 129| 35.7k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 35.7k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 35.7k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 35.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 359| 35.7k| xfree (cur.name); ------------------ | | 54| 35.7k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 360| 35.7k| xfree (cur.linkto); ------------------ | | 54| 35.7k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 361| 35.7k| continue; 362| 35.7k| } 363| | 364| 8.94k| if (!dir) ------------------ | Branch (364:11): [True: 652, False: 8.29k] ------------------ 365| 652| { 366| 652| l = dir = xnew (struct fileinfo); ------------------ | | 49| 652|#define xnew(type) (xmalloc (sizeof (type))) ------------------ 367| 652| memcpy (l, &cur, sizeof (cur)); 368| 652| l->prev = l->next = NULL; 369| 652| } 370| 8.29k| else 371| 8.29k| { 372| 8.29k| cur.prev = l; 373| 8.29k| l->next = xnew (struct fileinfo); ------------------ | | 49| 8.29k|#define xnew(type) (xmalloc (sizeof (type))) ------------------ 374| 8.29k| l = l->next; 375| 8.29k| memcpy (l, &cur, sizeof (cur)); 376| 8.29k| l->next = NULL; 377| 8.29k| } 378| | /* Get the current time. */ 379| 8.94k| timenow = time (NULL); 380| 8.94k| tnow = localtime (&timenow); 381| | /* Build the time-stamp (the idea by zaga@fly.cc.fer.hr). */ 382| 8.94k| timestruct.tm_sec = sec; 383| 8.94k| timestruct.tm_min = min; 384| 8.94k| timestruct.tm_hour = hour; 385| 8.94k| timestruct.tm_mday = day; 386| 8.94k| timestruct.tm_mon = month; 387| 8.94k| if (year == 0) ------------------ | Branch (387:11): [True: 4.89k, False: 4.05k] ------------------ 388| 4.89k| { 389| | /* Some listings will not specify the year if it is "obvious" 390| | that the file was from the previous year. E.g. if today 391| | is 97-01-12, and you see a file of Dec 15th, its year is 392| | 1996, not 1997. Thanks to Vladimir Volovich for 393| | mentioning this! */ 394| 4.89k| if (month > tnow->tm_mon) ------------------ | Branch (394:15): [True: 2.88k, False: 2.01k] ------------------ 395| 2.88k| timestruct.tm_year = tnow->tm_year - 1; 396| 2.01k| else 397| 2.01k| timestruct.tm_year = tnow->tm_year; 398| 4.89k| } 399| 4.05k| else 400| 4.05k| timestruct.tm_year = year; 401| 8.94k| if (timestruct.tm_year >= 1900) ------------------ | Branch (401:11): [True: 768, False: 8.17k] ------------------ 402| 768| timestruct.tm_year -= 1900; 403| 8.94k| timestruct.tm_wday = 0; 404| 8.94k| timestruct.tm_yday = 0; 405| 8.94k| timestruct.tm_isdst = -1; 406| 8.94k| l->tstamp = mktime (×truct); /* store the time-stamp */ 407| 8.94k| l->ptype = ptype; 408| 8.94k| } 409| | 410| 5.40k| xfree (line); ------------------ | | 54| 5.40k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 411| 5.40k| return dir; 412| 5.40k|} ftp-ls.c:clean_line: 72| 73.2k|{ 73| 73.2k| if (len <= 0) return 0; ------------------ | Branch (73:7): [True: 0, False: 73.2k] ------------------ 74| | 75| 142k| while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r')) ------------------ | Branch (75:10): [True: 138k, False: 4.45k] | Branch (75:22): [True: 65.0k, False: 73.0k] | Branch (75:47): [True: 4.28k, False: 68.7k] ------------------ 76| 69.3k| line[--len] = '\0'; 77| | 78| 73.2k| if (!len) return 0; ------------------ | Branch (78:7): [True: 4.45k, False: 68.7k] ------------------ 79| | 80| 1.30M| for ( ; *line ; line++ ) if (*line == '\t') *line = ' '; ------------------ | Branch (80:11): [True: 1.23M, False: 68.7k] | Branch (80:32): [True: 13.9k, False: 1.22M] ------------------ 81| | 82| 68.7k| return len; 83| 73.2k|} ftp-ls.c:symperms: 51| 15.7k|{ 52| 15.7k| int perms = 0, i; 53| | 54| 15.7k| if (strlen (s) < 9) ------------------ | Branch (54:7): [True: 14.0k, False: 1.75k] ------------------ 55| 14.0k| return 0; 56| 7.00k| for (i = 0; i < 3; i++, s += 3) ------------------ | Branch (56:15): [True: 5.25k, False: 1.75k] ------------------ 57| 5.25k| { 58| 5.25k| perms <<= 3; 59| 5.25k| perms += (((s[0] == 'r') << 2) + ((s[1] == 'w') << 1) + 60| 5.25k| (s[2] == 'x' || s[2] == 's')); ------------------ | Branch (60:18): [True: 630, False: 4.62k] | Branch (60:33): [True: 246, False: 4.37k] ------------------ 61| 5.25k| } 62| 1.75k| return perms; 63| 15.7k|} ftp-ls.c:ftp_parse_winnt_ls: 416| 874|{ 417| 874| int len; 418| 874| int year, month, day; /* for time analysis */ 419| 874| int hour, min; 420| 874| size_t bufsize = 0; 421| 874| struct tm timestruct; 422| | 423| 874| char *line = NULL, *tok; /* tokenizer */ 424| 874| char *filename; 425| 874| struct fileinfo *dir, *l, cur; /* list creation */ 426| | 427| 874| dir = l = NULL; 428| 874| cur.name = NULL; 429| | 430| | /* Line loop to end of file: */ 431| 4.25k| while ((len = getline (&line, &bufsize, fp)) > 0) ------------------ | Branch (431:10): [True: 3.37k, False: 874] ------------------ 432| 3.37k| { 433| 3.37k| len = clean_line (line, len); 434| | 435| | /* Name begins at 39 column of the listing if date presented in `mm-dd-yy' 436| | format or at 41 column if date presented in `mm-dd-yyyy' format. Thus, 437| | we cannot extract name before we parse date. Using this information we 438| | also can recognize filenames that begin with a series of space 439| | characters (but who really wants to use such filenames anyway?). */ 440| 3.37k| if (len < 40) continue; ------------------ | Branch (440:11): [True: 1.44k, False: 1.93k] ------------------ 441| 1.93k| filename = line + 39; 442| | 443| | /* First column: mm-dd-yy or mm-dd-yyyy. Should atoi() on the month fail, 444| | january will be assumed. */ 445| 1.93k| tok = strtok(line, "-"); 446| 1.93k| if (tok == NULL) continue; ------------------ | Branch (446:11): [True: 67, False: 1.86k] ------------------ 447| 1.86k| month = atoi(tok); 448| 1.86k| if (month < 0) month = 0; else month--; ------------------ | Branch (448:11): [True: 108, False: 1.75k] ------------------ 449| 1.86k| tok = strtok(NULL, "-"); 450| 1.86k| if (tok == NULL) continue; ------------------ | Branch (450:11): [True: 113, False: 1.75k] ------------------ 451| 1.75k| day = atoi(tok); 452| 1.75k| tok = strtok(NULL, " "); 453| 1.75k| if (tok == NULL) continue; ------------------ | Branch (453:11): [True: 87, False: 1.66k] ------------------ 454| 1.66k| year = atoi(tok); 455| | /* Assuming the epoch starting at 1.1.1970 */ 456| 1.66k| if (year <= 70) ------------------ | Branch (456:11): [True: 1.25k, False: 412] ------------------ 457| 1.25k| { 458| 1.25k| year += 100; 459| 1.25k| } 460| 412| else if (year >= 1900) ------------------ | Branch (460:16): [True: 276, False: 136] ------------------ 461| 276| { 462| 276| year -= 1900; 463| 276| if (len < 42) continue; ------------------ | Branch (463:15): [True: 93, False: 183] ------------------ 464| 183| filename += 2; 465| 183| } 466| | /* Now it is possible to determine the position of the first symbol in 467| | filename. */ 468| 1.57k| xfree (cur.name); ------------------ | | 54| 1.57k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 469| 1.57k| memset(&cur, 0, sizeof (cur)); 470| 1.57k| cur.name = xstrdup(filename); 471| 1.57k| DEBUGP (("Name: '%s'\n", cur.name)); ------------------ | | 129| 1.57k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 1.57k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 1.57k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 1.57k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 472| | 473| | 474| | /* Second column: hh:mm[AP]M, listing does not contain value for 475| | seconds */ 476| 1.57k| tok = strtok(NULL, ":"); 477| 1.57k| if (tok == NULL) continue; ------------------ | Branch (477:11): [True: 101, False: 1.47k] ------------------ 478| 1.47k| hour = atoi(tok); 479| 1.47k| tok = strtok(NULL, "M"); 480| 1.47k| if (tok == NULL) continue; ------------------ | Branch (480:11): [True: 148, False: 1.32k] ------------------ 481| 1.32k| min = atoi(tok); 482| | /* Adjust hour from AM/PM. Just for the record, the sequence goes 483| | 11:00AM, 12:00PM, 01:00PM ... 11:00PM, 12:00AM, 01:00AM . */ 484| 1.32k| if (tok[0] && tok[1]) tok+=2; ------------------ | Branch (484:11): [True: 1.32k, False: 0] | Branch (484:21): [True: 1.04k, False: 283] ------------------ 485| 1.32k| if (hour >= 12 || hour < 0) hour = 0; ------------------ | Branch (485:11): [True: 169, False: 1.15k] | Branch (485:25): [True: 164, False: 992] ------------------ 486| 1.32k| if (*tok == 'P') hour += 12; ------------------ | Branch (486:11): [True: 99, False: 1.22k] ------------------ 487| | 488| 1.32k| DEBUGP (("YYYY/MM/DD HH:MM - %d/%02d/%02d %02d:%02d\n", ------------------ | | 129| 1.32k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 1.32k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 1.32k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 1.32k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 489| 1.32k| year+1900, month, day, hour, min)); 490| | 491| | /* Build the time-stamp (copy & paste from above) */ 492| 1.32k| timestruct.tm_sec = 0; 493| 1.32k| timestruct.tm_min = min; 494| 1.32k| timestruct.tm_hour = hour; 495| 1.32k| timestruct.tm_mday = day; 496| 1.32k| timestruct.tm_mon = month; 497| 1.32k| timestruct.tm_year = year; 498| 1.32k| timestruct.tm_wday = 0; 499| 1.32k| timestruct.tm_yday = 0; 500| 1.32k| timestruct.tm_isdst = -1; 501| 1.32k| cur.tstamp = mktime (×truct); /* store the time-stamp */ 502| 1.32k| cur.ptype = TT_HOUR_MIN; 503| | 504| 1.32k| DEBUGP (("Timestamp: %ld\n", cur.tstamp)); ------------------ | | 129| 1.32k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 1.32k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 1.32k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 1.32k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 505| | 506| | /* Third column: Either file length, or . We also set the 507| | permissions (guessed as 0644 for plain files and 0755 for 508| | directories as the listing does not give us a clue) and filetype 509| | here. */ 510| 1.32k| tok = strtok(NULL, " "); 511| 1.32k| if (tok == NULL) continue; ------------------ | Branch (511:11): [True: 747, False: 578] ------------------ 512| 578| while ((tok != NULL) && (*tok == '\0')) tok = strtok(NULL, " "); ------------------ | Branch (512:14): [True: 578, False: 0] | Branch (512:31): [True: 0, False: 578] ------------------ 513| 578| if (tok == NULL) continue; ------------------ | Branch (513:11): [True: 0, False: 578] ------------------ 514| 578| if (*tok == '<') ------------------ | Branch (514:11): [True: 108, False: 470] ------------------ 515| 108| { 516| 108| cur.type = FT_DIRECTORY; 517| 108| cur.size = 0; 518| 108| cur.perms = 0755; 519| 108| DEBUGP (("Directory\n")); ------------------ | | 129| 108|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 108|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 108|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 108] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 520| 108| } 521| 470| else 522| 470| { 523| 470| wgint size; 524| 470| cur.type = FT_PLAINFILE; 525| 470| errno = 0; 526| 470| size = str_to_wgint (tok, NULL, 10); ------------------ | | 147| 470|#define str_to_wgint strtoll ------------------ 527| 470| if (size == WGINT_MAX && errno == ERANGE) ------------------ | | 145| 940|#define WGINT_MAX INT64_MAX ------------------ | Branch (527:15): [True: 148, False: 322] | Branch (527:36): [True: 66, False: 82] ------------------ 528| 66| cur.size = 0; /* overflow */ 529| 404| else 530| 404| cur.size = size; 531| 470| cur.perms = 0644; 532| 470| DEBUGP (("File, size %s bytes\n", number_to_static_string (cur.size))); ------------------ | | 129| 470|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 470|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 470|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 470] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 533| 470| } 534| | 535| 578| cur.linkto = NULL; 536| | 537| | /* And put everything into the linked list */ 538| 578| if (!dir) ------------------ | Branch (538:11): [True: 166, False: 412] ------------------ 539| 166| { 540| 166| l = dir = xnew (struct fileinfo); ------------------ | | 49| 166|#define xnew(type) (xmalloc (sizeof (type))) ------------------ 541| 166| memcpy (l, &cur, sizeof (cur)); 542| 166| l->prev = l->next = NULL; 543| 166| } 544| 412| else 545| 412| { 546| 412| cur.prev = l; 547| 412| l->next = xnew (struct fileinfo); ------------------ | | 49| 412|#define xnew(type) (xmalloc (sizeof (type))) ------------------ 548| 412| l = l->next; 549| 412| memcpy (l, &cur, sizeof (cur)); 550| 412| l->next = NULL; 551| 412| } 552| 578| cur.name = NULL; 553| 578| } 554| | 555| 874| xfree (cur.name); ------------------ | | 54| 874|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 556| 874| xfree (line); ------------------ | | 54| 874|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 557| 874| return dir; 558| 874|} ftp-ls.c:ftp_parse_vms_ls: 670| 2.09k|{ 671| 2.09k| int dt, i, j, len; 672| 2.09k| int perms; 673| 2.09k| size_t bufsize = 0; 674| 2.09k| time_t timenow; 675| 2.09k| struct tm *timestruct; 676| 2.09k| char date_str[32]; 677| | 678| 2.09k| char *line = NULL, *tok; /* tokenizer */ 679| 2.09k| struct fileinfo *dir, *l, cur; /* list creation */ 680| | 681| 2.09k| dir = l = NULL; 682| | 683| | /* Skip blank lines, Directory heading, and more blank lines. */ 684| | 685| 2.85k| for (j = 0; (i = getline (&line, &bufsize, fp)) > 0; ) ------------------ | Branch (685:15): [True: 2.82k, False: 23] ------------------ 686| 2.82k| { 687| 2.82k| i = clean_line (line, i); 688| 2.82k| if (i <= 0) ------------------ | Branch (688:11): [True: 753, False: 2.07k] ------------------ 689| 753| continue; /* Ignore blank line. */ 690| | 691| 2.07k| if ((j == 0) && (line[i - 1] == ']')) ------------------ | Branch (691:11): [True: 2.07k, False: 3] | Branch (691:23): [True: 5, False: 2.06k] ------------------ 692| 5| { 693| | /* Found Directory heading line. Next non-blank line 694| | is significant. */ 695| 5| j = 1; 696| 5| } 697| 2.07k| else if (!strncmp (line, "Total of ", 9)) ------------------ | Branch (697:16): [True: 1, False: 2.07k] ------------------ 698| 1| { 699| | /* Found "Total of ..." footing line. No valid data 700| | will follow (empty directory). */ 701| 1| i = 0; /* Arrange for early exit. */ 702| 1| break; 703| 1| } 704| 2.07k| else 705| 2.07k| { 706| 2.07k| break; /* Must be significant data. */ 707| 2.07k| } 708| 2.07k| } 709| | 710| | /* Read remainder of file until the next blank line or EOF. */ 711| | 712| 2.09k| cur.name = NULL; 713| 17.8k| while (i > 0) ------------------ | Branch (713:10): [True: 16.4k, False: 1.42k] ------------------ 714| 16.4k| { 715| 16.4k| char *p; 716| | 717| | /* The first token is the file name. After a long name, other 718| | data may be on the following line. A valid directory name ends 719| | in ".DIR;1" (any case), although some VMS FTP servers may omit 720| | the version number (";1"). 721| | */ 722| | 723| 16.4k| tok = strtok(line, " "); 724| 16.4k| if (tok == NULL) tok = line; ------------------ | Branch (724:11): [True: 1.21k, False: 15.2k] ------------------ 725| 16.4k| DEBUGP (("file name: '%s'\n", tok)); ------------------ | | 129| 16.4k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 16.4k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 16.4k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 16.4k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 726| | 727| | /* Stripping the version number on a VMS system would be wrong. 728| | It may be foolish on a non-VMS system, too, but that's someone 729| | else's problem. (Define PRESERVE_VMS_VERSIONS for proper 730| | operation on other operating systems.) 731| | 732| | 2005-02-23 SMS. 733| | ODS5 extended file names may contain escaped semi-colons, so 734| | the version number is identified as right-side decimal digits 735| | led by a non-escaped semi-colon. It may be absent. 736| | */ 737| | 738| 16.4k|#if (!defined( __VMS) && !defined( PRESERVE_VMS_VERSIONS)) 739| 19.2k| for (p = tok + strlen (tok); (--p > tok) && c_isdigit(*p); ); ------------------ | Branch (739:36): [True: 7.58k, False: 11.6k] | Branch (739:51): [True: 2.80k, False: 4.78k] ------------------ 740| 16.4k| if (p > tok && (*p == ';') && (*(p - 1) != '^')) ------------------ | Branch (740:11): [True: 4.78k, False: 11.6k] | Branch (740:22): [True: 681, False: 4.09k] | Branch (740:37): [True: 474, False: 207] ------------------ 741| 474| { 742| 474| *p = '\0'; 743| 474| } 744| 16.4k|#endif /* (!defined( __VMS) && !defined( PRESERVE_VMS_VERSIONS)) */ 745| | 746| | /* 2005-02-23 SMS. 747| | Eliminate "^" escape characters from ODS5 extended file name. 748| | (A caret is invalid in an ODS2 name, so this is always safe.) 749| | */ 750| 16.4k| eat_carets (tok); 751| 16.4k| DEBUGP (("file name-^: '%s'\n", tok)); ------------------ | | 129| 16.4k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 16.4k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 16.4k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 16.4k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 752| | 753| | /* Differentiate between a directory and any other file. A VMS 754| | listing may not include file protections (permissions). Set a 755| | default permissions value (according to the file type), which 756| | may be overwritten later. Store directory names without the 757| | ".DIR;1" file type and version number, as the plain name is 758| | what will work in a CWD command. 759| | */ 760| 16.4k| len = strlen (tok); 761| 16.4k| if (len >= 4 && !c_strncasecmp(tok + (len - 4), ".DIR", 4)) ------------------ | Branch (761:11): [True: 3.47k, False: 12.9k] | Branch (761:23): [True: 198, False: 3.28k] ------------------ 762| 198| { 763| 198| *(tok + (len - 4)) = '\0'; /* Discard ".DIR". */ 764| 198| cur.type = FT_DIRECTORY; 765| 198| cur.perms = VMS_DEFAULT_PROT_DIR; ------------------ | | 581| 198|#define VMS_DEFAULT_PROT_DIR 0755 ------------------ 766| 198| DEBUGP (("Directory (nv)\n")); ------------------ | | 129| 198|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 198|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 198|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 198] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 767| 198| } 768| 16.2k| else if (len >= 6 && !c_strncasecmp (tok + len - 6, ".DIR;1", 6)) ------------------ | Branch (768:16): [True: 2.52k, False: 13.7k] | Branch (768:28): [True: 194, False: 2.33k] ------------------ 769| 194| { 770| 194| *(tok + (len - 6)) = '\0'; /* Discard ".DIR;1". */ 771| 194| cur.type = FT_DIRECTORY; 772| 194| cur.perms = VMS_DEFAULT_PROT_DIR; ------------------ | | 581| 194|#define VMS_DEFAULT_PROT_DIR 0755 ------------------ 773| 194| DEBUGP (("Directory (v)\n")); ------------------ | | 129| 194|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 194|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 194|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 194] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 774| 194| } 775| 16.0k| else 776| 16.0k| { 777| 16.0k| cur.type = FT_PLAINFILE; 778| 16.0k| cur.perms = VMS_DEFAULT_PROT_FILE; ------------------ | | 580| 16.0k|#define VMS_DEFAULT_PROT_FILE 0644 ------------------ 779| 16.0k| DEBUGP (("File\n")); ------------------ | | 129| 16.0k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 16.0k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 16.0k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 16.0k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 780| 16.0k| } 781| 16.4k| xfree (cur.name); ------------------ | | 54| 16.4k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 782| 16.4k| cur.name = xstrdup (tok); 783| 16.4k| DEBUGP (("Name: '%s'\n", cur.name)); ------------------ | | 129| 16.4k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 16.4k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 16.4k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 16.4k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 784| | 785| | /* Null the date and time string. */ 786| 16.4k| *date_str = '\0'; 787| | 788| | /* VMS lacks symbolic links. */ 789| 16.4k| cur.linkto = NULL; 790| | 791| | /* VMS reports file sizes in (512-byte) disk blocks, not bytes, 792| | hence useless for an integrity check based on byte-count. 793| | Set size to unknown. 794| | */ 795| 16.4k| cur.size = 0; 796| | 797| | /* Get token 2, if any. A long name may force all other data onto 798| | a second line. If needed, read the second line. 799| | */ 800| | 801| 16.4k| tok = strtok (NULL, " "); 802| 16.4k| if (tok == NULL) ------------------ | Branch (802:11): [True: 6.59k, False: 9.84k] ------------------ 803| 6.59k| { 804| 6.59k| DEBUGP (("Getting additional line.\n")); ------------------ | | 129| 6.59k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 6.59k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 6.59k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 6.59k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 805| 6.59k| i = getline (&line, &bufsize, fp); 806| 6.59k| if (i <= 0) ------------------ | Branch (806:15): [True: 606, False: 5.99k] ------------------ 807| 606| { 808| 606| DEBUGP (("EOF. Leaving listing parser.\n")); ------------------ | | 129| 606|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 606|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 606|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 606] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 809| 606| break; 810| 606| } 811| | 812| | /* Second line must begin with " ". Otherwise, it's a first 813| | line (and we may be confused). 814| | */ 815| 5.99k| i = clean_line (line, i); 816| 5.99k| if (i <= 0) ------------------ | Branch (816:15): [True: 31, False: 5.96k] ------------------ 817| 31| { 818| | /* Blank line. End of significant file listing. */ 819| 31| DEBUGP (("Blank line. Leaving listing parser.\n")); ------------------ | | 129| 31|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 31|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 31|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 31] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 820| 31| break; 821| 31| } 822| 5.96k| else if (line[0] != ' ') ------------------ | Branch (822:20): [True: 5.53k, False: 428] ------------------ 823| 5.53k| { 824| 5.53k| DEBUGP (("Non-blank in column 1. Must be a new file name?\n")); ------------------ | | 129| 5.53k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 5.53k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 5.53k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 5.53k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 825| 5.53k| continue; 826| 5.53k| } 827| 428| else 828| 428| { 829| 428| tok = strtok (line, " "); 830| 428| if (tok == NULL) ------------------ | Branch (830:19): [True: 11, False: 417] ------------------ 831| 11| { 832| | /* Unexpected non-empty but apparently blank line. */ 833| 11| DEBUGP (("Null token. Leaving listing parser.\n")); ------------------ | | 129| 11|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 11|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 11|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 11] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 834| 11| break; 835| 11| } 836| 428| } 837| 5.99k| } 838| | 839| | /* Analyze tokens. (Order is not significant, except date must 840| | precede time.) 841| | 842| | Size: ddd or ddd/ddd (where "ddd" is a decimal number) 843| | Date: DD-MMM-YYYY 844| | Time: HH:MM or HH:MM:SS or HH:MM:SS.CC 845| | Owner: [user] or [user,group] 846| | Protection: (ppp,ppp,ppp,ppp) (where "ppp" is "RWED" or some 847| | subset thereof, for System, Owner, Group, World. 848| | 849| | If permission is lacking, info may be replaced by the string: 850| | "No privilege for attempted operation". 851| | */ 852| 52.2k| while (tok != NULL) ------------------ | Branch (852:14): [True: 41.9k, False: 10.2k] ------------------ 853| 41.9k| { 854| 41.9k| DEBUGP (("Token: >%s<: ", tok)); ------------------ | | 129| 41.9k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 41.9k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 41.9k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 41.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 855| | 856| 41.9k| if ((strlen (tok) < 12) && (strchr( tok, '-') != NULL)) ------------------ | Branch (856:15): [True: 40.0k, False: 1.97k] | Branch (856:38): [True: 3.24k, False: 36.7k] ------------------ 857| 3.24k| { 858| | /* Date. */ 859| 3.24k| DEBUGP (("Date.\n")); ------------------ | | 129| 3.24k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 3.24k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 3.24k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 3.24k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 860| 3.24k| snprintf(date_str, sizeof(date_str), "%s ", tok); 861| 3.24k| } 862| 38.7k| else if ((strlen (tok) < 12) && (strchr( tok, ':') != NULL)) ------------------ | Branch (862:20): [True: 36.7k, False: 1.97k] | Branch (862:43): [True: 1.76k, False: 34.9k] ------------------ 863| 1.76k| { 864| | /* Time. */ 865| 1.76k| DEBUGP (("Time. ")); ------------------ | | 129| 1.76k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 1.76k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 1.76k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 1.76k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 866| 1.76k| strncat( date_str, 867| 1.76k| tok, 868| 1.76k| (sizeof( date_str)- strlen (date_str) - 1)); 869| 1.76k| DEBUGP (("Date time: >%s<\n", date_str)); ------------------ | | 129| 1.76k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 1.76k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 1.76k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 1.76k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 870| 1.76k| } 871| 36.9k| else if (strchr (tok, '[') != NULL) ------------------ | Branch (871:20): [True: 4.64k, False: 32.3k] ------------------ 872| 4.64k| { 873| | /* Owner. (Ignore.) */ 874| 4.64k| DEBUGP (("Owner.\n")); ------------------ | | 129| 4.64k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 4.64k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 4.64k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 4.64k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 875| 4.64k| } 876| 32.3k| else if (strchr (tok, '(') != NULL) ------------------ | Branch (876:20): [True: 1.06k, False: 31.2k] ------------------ 877| 1.06k| { 878| | /* Protections (permissions). */ 879| 1.06k| perms = 0; 880| 1.06k| j = 0; 881| | /*FIXME: Should not be using the variable like this. */ 882| 48.4k| for (i = 0; i < (int) strlen(tok); i++) ------------------ | Branch (882:27): [True: 47.3k, False: 1.06k] ------------------ 883| 47.3k| { 884| 47.3k| switch (tok[ i]) ------------------ | Branch (884:27): [True: 22.4k, False: 24.8k] ------------------ 885| 47.3k| { 886| 1.33k| case '(': ------------------ | Branch (886:21): [True: 1.33k, False: 46.0k] ------------------ 887| 1.33k| break; 888| 11| case ')': ------------------ | Branch (888:21): [True: 11, False: 47.3k] ------------------ 889| 11| break; 890| 19.4k| case ',': ------------------ | Branch (890:21): [True: 19.4k, False: 27.8k] ------------------ 891| 19.4k| if (j == 0) ------------------ | Branch (891:27): [True: 440, False: 19.0k] ------------------ 892| 440| { 893| 440| perms = 0; 894| 440| } 895| 19.0k| else if (j < 4) ------------------ | Branch (895:32): [True: 585, False: 18.4k] ------------------ 896| 585| { 897| 585| perms <<= 3; 898| 585| } 899| 19.4k| j++; 900| 19.4k| break; 901| 1.20k| case 'R': ------------------ | Branch (901:21): [True: 1.20k, False: 46.1k] ------------------ 902| 1.20k| perms |= 4; 903| 1.20k| break; 904| 300| case 'W': ------------------ | Branch (904:21): [True: 300, False: 47.0k] ------------------ 905| 300| perms |= 2; 906| 300| break; 907| 674| case 'E': ------------------ | Branch (907:21): [True: 674, False: 46.6k] ------------------ 908| 674| perms |= 1; 909| 674| break; 910| 1.86k| case 'D': ------------------ | Branch (910:21): [True: 1.86k, False: 45.4k] ------------------ 911| 1.86k| perms |= 2; 912| 1.86k| break; 913| 47.3k| } 914| 47.3k| } 915| 1.06k| cur.perms = perms; 916| 1.06k| DEBUGP (("Prot. perms = %0o.\n", (unsigned) cur.perms)); ------------------ | | 129| 1.06k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 1.06k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 1.06k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 1.06k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 917| 1.06k| } 918| 31.2k| else 919| 31.2k| { 920| | /* Nondescript. Probably size(s), probably in blocks. 921| | Could be "No privilege ..." message. (Ignore.) 922| | */ 923| 31.2k| DEBUGP (("Ignored (size?).\n")); ------------------ | | 129| 31.2k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 31.2k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 31.2k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 31.2k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 924| 31.2k| } 925| | 926| 41.9k| tok = strtok (NULL, " "); 927| 41.9k| } 928| | 929| | /* Tokens exhausted. Interpret the data, and fill in the 930| | structure. 931| | */ 932| | /* Fill tm timestruct according to date-time string. Fractional 933| | seconds are ignored. Default to current time, if conversion 934| | fails. 935| | */ 936| 10.2k| timenow = time( NULL); 937| 10.2k| timestruct = localtime( &timenow ); 938| 10.2k| strptime( date_str, "%d-%b-%Y %H:%M:%S", timestruct); 939| | 940| | /* Convert struct tm local time to time_t local time. */ 941| 10.2k| timenow = mktime (timestruct); 942| | /* Offset local time according to environment variable (seconds). */ 943| 10.2k| if ((tok = getenv ( "WGET_TIMEZONE_DIFFERENTIAL")) != NULL) ------------------ | Branch (943:11): [True: 0, False: 10.2k] ------------------ 944| 0| { 945| 0| dt = atoi (tok); 946| 0| DEBUGP (("Time differential = %d.\n", dt)); ------------------ | | 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] | | ------------------ ------------------ 947| 0| } 948| 10.2k| else 949| 10.2k| dt = 0; 950| | 951| 10.2k| if (dt >= 0) ------------------ | Branch (951:11): [True: 10.2k, False: 0] ------------------ 952| 10.2k| timenow += dt; 953| 0| else 954| 0| timenow -= (-dt); 955| | 956| 10.2k| cur.tstamp = timenow; /* Store the time-stamp. */ 957| 10.2k| DEBUGP (("Timestamp: %ld\n", cur.tstamp)); ------------------ | | 129| 10.2k|#define DEBUGP(args) do { IF_DEBUG { debug_logprintf args; } } while (0) | | ------------------ | | | | 119| 10.2k|# define IF_DEBUG if (UNLIKELY (opt.debug)) | | | | ------------------ | | | | | | 108| 10.2k|# define UNLIKELY(exp) __builtin_expect ((exp), 0) | | | | | | ------------------ | | | | | | | Branch (108:24): [True: 0, False: 10.2k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (129:71): [Folded - Ignored] | | ------------------ ------------------ 958| 10.2k| cur.ptype = TT_HOUR_MIN; 959| | 960| | /* Add the data for this item to the linked list, */ 961| 10.2k| if (!dir) ------------------ | Branch (961:11): [True: 1.48k, False: 8.78k] ------------------ 962| 1.48k| { 963| 1.48k| l = dir = xmalloc (sizeof (struct fileinfo)); 964| 1.48k| cur.prev = cur.next = NULL; 965| 1.48k| memcpy (l, &cur, sizeof (cur)); 966| 1.48k| } 967| 8.78k| else 968| 8.78k| { 969| 8.78k| cur.prev = l; 970| 8.78k| cur.next = NULL; 971| 8.78k| l->next = xmalloc (sizeof (struct fileinfo)); 972| 8.78k| l = l->next; 973| 8.78k| memcpy (l, &cur, sizeof (cur)); 974| 8.78k| } 975| 10.2k| cur.name = NULL; 976| | 977| 10.2k| i = getline (&line, &bufsize, fp); 978| 10.2k| if (i > 0) ------------------ | Branch (978:11): [True: 8.85k, False: 1.40k] ------------------ 979| 8.85k| { 980| 8.85k| i = clean_line (line, i); 981| 8.85k| if (i <= 0) ------------------ | Branch (981:15): [True: 18, False: 8.84k] ------------------ 982| 18| { 983| | /* Blank line. End of significant file listing. */ 984| 18| break; 985| 18| } 986| 8.85k| } 987| 10.2k| } 988| | 989| 2.09k| xfree (cur.name); ------------------ | | 54| 2.09k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 990| 2.09k| xfree (line); ------------------ | | 54| 2.09k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 991| 2.09k| return dir; 992| 2.09k|} ftp-ls.c:eat_carets: 594| 16.4k|{ 595| 16.4k| char *strd; /* Destination pointer. */ 596| 16.4k| char hdgt; 597| 16.4k| unsigned char uchr; 598| | 599| | /* Skip ahead to the first "^", if any. */ 600| 89.4k| while ((*str != '\0') && (*str != '^')) ------------------ | Branch (600:10): [True: 74.8k, False: 14.5k] | Branch (600:28): [True: 73.0k, False: 1.85k] ------------------ 601| 73.0k| str++; 602| | 603| | /* If no caret was found, quit early. */ 604| 16.4k| if (*str != '\0') ------------------ | Branch (604:7): [True: 1.85k, False: 14.5k] ------------------ 605| 1.85k| { 606| | /* Shift characters leftward as carets are found. */ 607| 1.85k| strd = str; 608| 18.4k| while (*str != '\0') ------------------ | Branch (608:12): [True: 16.6k, False: 1.85k] ------------------ 609| 16.6k| { 610| 16.6k| uchr = *str; 611| 16.6k| if (uchr == '^') ------------------ | Branch (611:11): [True: 5.77k, False: 10.8k] ------------------ 612| 5.77k| { 613| | /* Found a caret. Skip it, and check the next character. */ 614| 5.77k| if ((char_prop[(unsigned char) str[1]] & 64) && (char_prop[(unsigned char) str[2]] & 64)) ------------------ | Branch (614:13): [True: 1.92k, False: 3.85k] | Branch (614:57): [True: 1.43k, False: 491] ------------------ 615| 1.43k| { 616| | /* Hex digit. Get char code from this and next hex digit. */ 617| 1.43k| uchr = *(++str); 618| 1.43k| if (uchr <= '9') ------------------ | Branch (618:15): [True: 1.15k, False: 288] ------------------ 619| 1.15k| { 620| 1.15k| hdgt = uchr - '0'; /* '0' - '9' -> 0 - 9. */ 621| 1.15k| } 622| 288| else 623| 288| { 624| 288| hdgt = ((uchr - 'A') & 7) + 10; /* [Aa] - [Ff] -> 10 - 15. */ 625| 288| } 626| 1.43k| hdgt <<= 4; /* X16. */ 627| 1.43k| uchr = *(++str); /* Next char must be hex digit. */ 628| 1.43k| if (uchr <= '9') ------------------ | Branch (628:15): [True: 1.17k, False: 264] ------------------ 629| 1.17k| { 630| 1.17k| uchr = hdgt + uchr - '0'; 631| 1.17k| } 632| 264| else 633| 264| { 634| 264| uchr = hdgt + ((uchr - 'A') & 15) + 10; 635| 264| } 636| 1.43k| } 637| 4.34k| else if (uchr == '_') ------------------ | Branch (637:18): [True: 0, False: 4.34k] ------------------ 638| 0| { 639| | /* Convert escaped "_" to " ". */ 640| 0| uchr = ' '; 641| 0| } 642| 4.34k| else if (uchr == '/') ------------------ | Branch (642:18): [True: 0, False: 4.34k] ------------------ 643| 0| { 644| | /* Convert escaped "/" (invalid Zip) to "?" (invalid VMS). */ 645| | /* Note that this is a left-over from Info-ZIP code, and is 646| | probably of little value here, except perhaps to avoid 647| | directory confusion which an unconverted slash might cause. 648| | */ 649| 0| uchr = '?'; 650| 0| } 651| | /* Else, not a hex digit. Must be a simple escaped character 652| | (or Unicode, which is not yet handled here). 653| | */ 654| 5.77k| } 655| | /* Else, not a caret. Use as-is. */ 656| 16.6k| *strd = uchr; 657| | 658| | /* Advance destination and source pointers. */ 659| 16.6k| strd++; 660| 16.6k| str++; 661| 16.6k| } 662| | /* Terminate the destination string. */ 663| 1.85k| *strd = '\0'; 664| 1.85k| } 665| 16.4k|} freefileinfo: 2884| 8.37k|{ 2885| 28.1k| while (f) ------------------ | Branch (2885:10): [True: 19.7k, False: 8.37k] ------------------ 2886| 19.7k| { 2887| 19.7k| struct fileinfo *next = f->next; 2888| 19.7k| xfree (f->name); ------------------ | | 54| 19.7k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 2889| 19.7k| xfree (f->linkto); ------------------ | | 54| 19.7k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 2890| 19.7k| xfree (f); ------------------ | | 54| 19.7k|#define xfree(p) do { free ((void *) (p)); p = NULL; } while (0) | | ------------------ | | | Branch (54:63): [Folded - Ignored] | | ------------------ ------------------ 2891| 19.7k| f = next; 2892| 19.7k| } 2893| 8.37k|}