├── dummy
├── www
    ├── index.html
    ├── .htaccess
    ├── footer.html
    ├── towel.jpg
    ├── toycans.png
    ├── toycans-big.jpg
    ├── downloads
    │   └── binaries
    │   │   ├── toolchains
    │   │       └── README
    │   │   └── mkroot
    │   │       └── README
    └── release.txt
├── tests
    ├── files
    │   ├── zip
    │   │   ├── d1
    │   │   │   └── d2
    │   │   │   │   ├── a.txt
    │   │   │   │   ├── empty.txt
    │   │   │   │   ├── b.txt
    │   │   │   │   ├── c.txt
    │   │   │   │   └── x.txt
    │   │   └── example.zip
    │   ├── utf8
    │   │   ├── 0xabad1dea.txt
    │   │   ├── japan.txt
    │   │   ├── arabic.txt
    │   │   ├── bad.txt
    │   │   ├── test1.txt
    │   │   └── test2.txt
    │   ├── bc
    │   │   ├── arrays_results.txt
    │   │   ├── pi.txt
    │   │   ├── arctan.txt
    │   │   ├── misc_results.txt
    │   │   ├── arrays.txt
    │   │   ├── misc2_results.txt
    │   │   ├── misc.txt
    │   │   ├── sqrt.txt
    │   │   ├── exponent.txt
    │   │   ├── log.txt
    │   │   ├── sqrt_results.txt
    │   │   ├── script.sh
    │   │   ├── misc1_results.txt
    │   │   ├── vars_results.txt
    │   │   ├── vars.txt
    │   │   ├── cosine.txt
    │   │   ├── misc2.txt
    │   │   ├── power.txt
    │   │   ├── log_results.txt
    │   │   ├── exponent_results.txt
    │   │   ├── modulus_results.txt
    │   │   ├── divide_results.txt
    │   │   ├── misc1.txt
    │   │   ├── cosine_results.txt
    │   │   ├── subtract_results.txt
    │   │   ├── multiply_results.txt
    │   │   ├── modulus.txt
    │   │   ├── boolean_results.txt
    │   │   ├── power_results.txt
    │   │   ├── divide.txt
    │   │   ├── add_results.txt
    │   │   ├── subtract.txt
    │   │   └── multiply.txt
    │   ├── elf
    │   │   ├── fdstatic
    │   │   ├── ndk-elf-note-full
    │   │   ├── ndk-elf-note-short
    │   │   └── ndk-elf-note-shflags
    │   ├── java.class
    │   ├── tar
    │   │   ├── tar.7z
    │   │   ├── tar.tbz2
    │   │   ├── tar.tgz
    │   │   ├── oldsparse.tgz
    │   │   └── long_path.tar
    │   ├── blkid
    │   │   ├── ext2.bz2
    │   │   ├── ext3.bz2
    │   │   ├── ext4.bz2
    │   │   ├── f2fs.bz2
    │   │   ├── iso.bz2
    │   │   ├── ntfs.bz2
    │   │   ├── vfat.bz2
    │   │   ├── xfs.bz2
    │   │   ├── cramfs.bz2
    │   │   ├── fat32.bz2
    │   │   ├── minix.bz2
    │   │   ├── msdos.bz2
    │   │   ├── reiser3.bz2
    │   │   └── squashfs.bz2
    │   └── bzcat
    │   │   ├── badcrc.bz2
    │   │   └── overflow.bz2
    ├── sha224sum.test
    ├── sha256sum.test
    ├── sha384sum.test
    ├── sha3sum.test
    ├── sha512sum.test
    ├── uuidgen.test
    ├── tee.test
    ├── fallocate.test
    ├── ps.test
    ├── kill.test
    ├── tsort.test
    ├── uptime.test
    ├── hostname.test
    ├── netcat.test
    ├── README.txt
    ├── dirname.test
    ├── more.test
    ├── comm.test
    ├── tr.test
    ├── httpd.test
    ├── bzcat.test
    ├── top.test
    ├── zcat.test
    ├── killall.test
    ├── mkfifo.test
    ├── fstype.test
    ├── stat.test
    ├── unicode.test
    ├── pwd.test
    ├── bc.test
    ├── install.test
    ├── iconv.test
    ├── link.test
    ├── uuencode.test
    ├── pidof.test
    ├── setfattr.test
    ├── rev.test
    ├── id.test
    ├── uudecode.test
    ├── cat.test
    ├── factor.test
    ├── getfattr.test
    ├── basename.test
    ├── demo_number.test
    ├── mkpasswd.test
    ├── tac.test
    ├── strings.test
    ├── split.test
    ├── paste.test
    ├── env.test
    ├── chown.test
    ├── losetup.test
    ├── cksum.test
    ├── groupdel.test
    ├── xzcat.test
    ├── taskset.test
    ├── fold.test
    ├── vi.test
    ├── base64.test
    ├── truncate.test
    ├── expand.test
    ├── base32.test
    ├── head.test
    ├── getopt.test
    ├── timeout.test
    ├── fmt.test
    └── lsattr.test
├── scripts
    ├── prereq
    │   ├── generated
    │   │   ├── tags.h
    │   │   ├── flags.h
    │   │   └── help.h
    │   └── build.sh
    ├── mkroot.sh
    ├── probes
    │   ├── README
    │   ├── GLOBALS
    │   ├── findglobals
    │   ├── showasm
    │   ├── cmd2dpkg
    │   └── bloatcheck
    ├── change.sh
    ├── git-static-index.sh
    └── install.c
├── toys
    ├── other
    │   ├── pwgen.c
    │   ├── clear.c
    │   ├── README
    │   ├── nologin.c
    │   ├── uuidgen.c
    │   ├── freeramdisk.c
    │   ├── usleep.c
    │   ├── fsfreeze.c
    │   ├── linux32.c
    │   ├── w.c
    │   ├── reset.c
    │   ├── partprobe.c
    │   ├── pwdx.c
    │   ├── tac.c
    │   ├── fsync.c
    │   ├── fallocate.c
    │   ├── readahead.c
    │   ├── memeater.c
    │   ├── rev.c
    │   ├── swapon.c
    │   ├── flock.c
    │   ├── pivot_root.c
    │   ├── mcookie.c
    │   ├── printenv.c
    │   ├── setfattr.c
    │   ├── chroot.c
    │   ├── swapoff.c
    │   ├── lsmod.c
    │   ├── rmmod.c
    │   ├── chcon.c
    │   ├── yes.c
    │   ├── reboot.c
    │   ├── insmod.c
    │   ├── hd.c
    │   ├── setsid.c
    │   ├── watchdog.c
    │   ├── mkswap.c
    │   ├── ts.c
    │   ├── shuf.c
    │   ├── free.c
    │   └── which.c
    ├── android
    │   ├── README
    │   ├── runcon.c
    │   ├── getenforce.c
    │   ├── load_policy.c
    │   ├── setenforce.c
    │   ├── sendevent.c
    │   └── restorecon.c
    ├── posix
    │   ├── README
    │   ├── false.c
    │   ├── true.c
    │   ├── unlink.c
    │   ├── dirname.c
    │   ├── link.c
    │   ├── tty.c
    │   ├── sleep.c
    │   ├── mkfifo.c
    │   ├── nohup.c
    │   ├── nice.c
    │   ├── who.c
    │   ├── basename.c
    │   ├── renice.c
    │   ├── rmdir.c
    │   ├── mkdir.c
    │   ├── pwd.c
    │   ├── uname.c
    │   ├── uuencode.c
    │   └── tee.c
    ├── net
    │   ├── README
    │   └── tunctl.c
    ├── lsb
    │   ├── README
    │   ├── sync.c
    │   ├── pidof.c
    │   └── mknod.c
    ├── example
    │   ├── demo_many_options.c
    │   ├── hostid.c
    │   ├── README
    │   ├── hello.c
    │   ├── demo_number.c
    │   └── demo_utf8towc.c
    └── pending
    │   └── README
├── mkroot
    ├── packages
    │   ├── overlay
    │   ├── tests
    │   ├── dynamic
    │   ├── lfs-sources
    │   └── busybox
    ├── README.root
    ├── record-commands
    └── tar-for-web.sh
├── .gitignore
├── kconfig
    ├── lxdialog
    │   └── BIG.FAT.WARNING
    └── README
├── LICENSE
├── .github
    └── workflows
    │   └── toybox.yml
├── configure
└── lib
    └── toyflags.h


/dummy:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/www/index.html:
--------------------------------------------------------------------------------
1 | about.html


--------------------------------------------------------------------------------
/tests/files/zip/d1/d2/a.txt:
--------------------------------------------------------------------------------
1 | a
2 | 


--------------------------------------------------------------------------------
/tests/files/zip/d1/d2/empty.txt:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/tests/sha224sum.test:
--------------------------------------------------------------------------------
1 | sha1sum.test


--------------------------------------------------------------------------------
/tests/sha256sum.test:
--------------------------------------------------------------------------------
1 | sha1sum.test


--------------------------------------------------------------------------------
/tests/sha384sum.test:
--------------------------------------------------------------------------------
1 | sha1sum.test


--------------------------------------------------------------------------------
/tests/sha3sum.test:
--------------------------------------------------------------------------------
1 | sha1sum.test


--------------------------------------------------------------------------------
/tests/sha512sum.test:
--------------------------------------------------------------------------------
1 | sha1sum.test


--------------------------------------------------------------------------------
/www/.htaccess:
--------------------------------------------------------------------------------
1 | Xbithack on
2 | 


--------------------------------------------------------------------------------
/scripts/prereq/generated/tags.h:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/tests/files/zip/d1/d2/b.txt:
--------------------------------------------------------------------------------
1 | bb
2 | 


--------------------------------------------------------------------------------
/tests/files/zip/d1/d2/c.txt:
--------------------------------------------------------------------------------
1 | ccc
2 | 


--------------------------------------------------------------------------------
/tests/files/utf8/0xabad1dea.txt:
--------------------------------------------------------------------------------
1 | ‮ ασσιλέΜ ‭
2 | 


--------------------------------------------------------------------------------
/tests/files/bc/arrays_results.txt:
--------------------------------------------------------------------------------
1 | 2
2 | 4
3 | 2
4 | 


--------------------------------------------------------------------------------
/tests/files/utf8/japan.txt:
--------------------------------------------------------------------------------
1 | 私はガラスを食べられます。それは私を傷つけません。


--------------------------------------------------------------------------------
/scripts/mkroot.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/printf Moved to mkroot/mkroot.sh\n\c%s
2 | 


--------------------------------------------------------------------------------
/www/footer.html:
--------------------------------------------------------------------------------
1 | </td></tr></table>
2 | </table>
3 | </body>
4 | </html>
5 | 


--------------------------------------------------------------------------------
/www/towel.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/www/towel.jpg


--------------------------------------------------------------------------------
/www/toycans.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/www/toycans.png


--------------------------------------------------------------------------------
/toys/other/pwgen.c:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/toys/other/pwgen.c


--------------------------------------------------------------------------------
/www/toycans-big.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/www/toycans-big.jpg


--------------------------------------------------------------------------------
/scripts/probes/README:
--------------------------------------------------------------------------------
1 | Various development scripts to ask questions about a toybox binary.
2 | 


--------------------------------------------------------------------------------
/tests/files/bc/pi.txt:
--------------------------------------------------------------------------------
1 | for (i = 0; i <= 100; ++i) {
2 | 	scale = i
3 | 	4 * a(1)
4 | }
5 | 


--------------------------------------------------------------------------------
/tests/files/elf/fdstatic:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/elf/fdstatic


--------------------------------------------------------------------------------
/tests/files/java.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/java.class


--------------------------------------------------------------------------------
/tests/files/tar/tar.7z:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/tar/tar.7z


--------------------------------------------------------------------------------
/tests/files/tar/tar.tbz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/tar/tar.tbz2


--------------------------------------------------------------------------------
/tests/files/tar/tar.tgz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/tar/tar.tgz


--------------------------------------------------------------------------------
/tests/files/utf8/arabic.txt:
--------------------------------------------------------------------------------
1 | بلدي الحوامات مليء الثعابين
2 | وأنا لن شراء هذه السجائر مخدوش ذلك.


--------------------------------------------------------------------------------
/tests/files/utf8/bad.txt:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/utf8/bad.txt


--------------------------------------------------------------------------------
/tests/files/blkid/ext2.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/ext2.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/ext3.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/ext3.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/ext4.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/ext4.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/f2fs.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/f2fs.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/iso.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/iso.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/ntfs.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/ntfs.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/vfat.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/vfat.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/xfs.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/xfs.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/cramfs.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/cramfs.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/fat32.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/fat32.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/minix.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/minix.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/msdos.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/msdos.bz2


--------------------------------------------------------------------------------
/tests/files/blkid/reiser3.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/reiser3.bz2


--------------------------------------------------------------------------------
/tests/files/bzcat/badcrc.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/bzcat/badcrc.bz2


--------------------------------------------------------------------------------
/tests/files/tar/oldsparse.tgz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/tar/oldsparse.tgz


--------------------------------------------------------------------------------
/tests/files/zip/example.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/zip/example.zip


--------------------------------------------------------------------------------
/tests/files/blkid/squashfs.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/blkid/squashfs.bz2


--------------------------------------------------------------------------------
/tests/files/bzcat/overflow.bz2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/bzcat/overflow.bz2


--------------------------------------------------------------------------------
/scripts/prereq/generated/flags.h:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/scripts/prereq/generated/flags.h


--------------------------------------------------------------------------------
/tests/files/bc/arctan.txt:
--------------------------------------------------------------------------------
1 | for (i = 1; i <= 100; i++) {
2 |   scale = i
3 |   a(.267)
4 |   a(1)
5 | }
6 | halt
7 | 


--------------------------------------------------------------------------------
/tests/files/bc/misc_results.txt:
--------------------------------------------------------------------------------
1 | -1284597623836.9
2 | -1284597623836.9
3 | -4483684050181.80
4 | -4483684050181.80
5 | 


--------------------------------------------------------------------------------
/tests/files/elf/ndk-elf-note-full:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/elf/ndk-elf-note-full


--------------------------------------------------------------------------------
/tests/files/elf/ndk-elf-note-short:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/elf/ndk-elf-note-short


--------------------------------------------------------------------------------
/mkroot/packages/overlay:
--------------------------------------------------------------------------------
1 | #!/bin/echo Try "mkroot/mkroot.sh overlay"
2 | 
3 | cp -a "${OVERLAY:=overlay}"/. "$ROOT"/.
4 | 


--------------------------------------------------------------------------------
/tests/files/elf/ndk-elf-note-shflags:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/landley/toybox/HEAD/tests/files/elf/ndk-elf-note-shflags


--------------------------------------------------------------------------------
/tests/files/bc/arrays.txt:
--------------------------------------------------------------------------------
 1 | a[0] = 1
 2 | a[2-1] = 2
 3 | 
 4 | a[0]+a[0]
 5 | 
 6 | a[2-1]+a[2-1]
 7 | 
 8 | a[5] = 2
 9 | a[5.789]
10 | 
11 | 


--------------------------------------------------------------------------------
/tests/files/utf8/test1.txt:
--------------------------------------------------------------------------------
1 | l̴̗̞̠ȩ̸̩̥ṱ̴͍̻ ̴̲͜ͅt̷͇̗̮h̵̥͉̝e̴̡̺̼ ̸̤̜͜ŗ̴͓͉i̶͉͓͎t̷̞̝̻u̶̻̫̗a̴̺͎̯l̴͍͜ͅ ̵̩̲̱c̷̩̟̖o̴̠͍̻m̸͚̬̘ṃ̷̢͜e̵̗͎̫n̸̨̦̖c̷̰̩͎e̴̱̞̗
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | syntax: glob
 2 | /.config*
 3 | /.single*
 4 | /change/
 5 | /generated/
 6 | /kconfig/mconf
 7 | /kconfig/conf
 8 | /kconfig/*.c
 9 | /toybox
10 | /toybox_unstripped
11 | 


--------------------------------------------------------------------------------
/tests/files/utf8/test2.txt:
--------------------------------------------------------------------------------
1 | l̴̗̞̠ȩ̸̩̥ṱ̴͍̻ ̴̲͜ͅt̷͇̗̮h̵̥͉̝e̴̡̺̼ ̸̤̜͜ŗ̴͓͉i̶͉͓͎t̷̞̝̻u̶̻̫̗a̴̺͎̯l̴͍͜ͅ ̵̩̲̱c̷̩̟̖o̴̠͍̻m̸͚̬̘ṃ̷̢͜e̵̗͎̫n̸̨̦̖c̷̰̩͎e̴̱̞̗
2 | the̡ ҉̷ŕ͠͡į͞ţų͠al͘ ̛͏i͘҉s̛ ͜͞ḉ͏om̶͏pl̵͜ęt̴͠e̛
3 | 


--------------------------------------------------------------------------------
/toys/android/README:
--------------------------------------------------------------------------------
1 | Android commands
2 | 
3 | Commands primarily used by Android, not present in vanilla Linux.
4 | (Mostly SELinux stuff.)
5 | 
6 | Bug Elliott Hughes <enh@google.com> about this.
7 | 


--------------------------------------------------------------------------------
/tests/files/bc/misc2_results.txt:
--------------------------------------------------------------------------------
 1 | xy1
 2 | xy2
 3 | yx3
 4 | xy4
 5 | xy5
 6 | yx6
 7 | xz11
 8 | xz12
 9 | zx13
10 | xz14
11 | xz15
12 | zx16
13 | -10
14 | -9
15 | -8
16 | -7
17 | -6
18 | -5
19 | 0
20 | -9
21 | 


--------------------------------------------------------------------------------
/toys/posix/README:
--------------------------------------------------------------------------------
1 | Posix commands
2 | 
3 | Commands defined in POSIX-2008, also known as the Single Unix
4 | Specification version 4, available online at
5 | http://pubs.opengroup.org/onlinepubs/9699919799/idx/utilities.html
6 | 


--------------------------------------------------------------------------------
/kconfig/lxdialog/BIG.FAT.WARNING:
--------------------------------------------------------------------------------
1 | This is NOT the official version of dialog.  This version has been
2 | significantly modified from the original.  It is for use by the Linux
3 | kernel configuration script.  Please do not bother Savio Lam with 
4 | questions about this program.
5 | 


--------------------------------------------------------------------------------
/tests/uuidgen.test:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | [ -f testing.sh ] && . testing.sh
4 | 
5 | #testing "name" "command" "result" "infile" "stdin"
6 | 
7 | testing "smoke" "uuidgen | grep -Eq '[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}' && echo okay" "okay\n" "" ""
8 | 


--------------------------------------------------------------------------------
/tests/files/bc/misc.txt:
--------------------------------------------------------------------------------
 1 | 4.1*1.-13^ - 74 - 1284597623841*1.-13^ - 757
 2 | 4.1*1.\
 3 | -1\
 4 | 3^ - 74 - 1284597623841*1.\
 5 | -1\
 6 | 3^ - 757
 7 | obase = 9
 8 | 4.1*1.-13^ - 74 - 1284597623841*1.-13^ - 757
 9 | 4.1*1.\
10 | -1\
11 | 3^ - 74 - 1284597623841*1.\
12 | -1\
13 | 3^ - 757
14 | 


--------------------------------------------------------------------------------
/tests/tee.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "" "tee" "one" "" "one"
 8 | testing "" "tee -" "two\n" "" "two\n"
 9 | testing "" "tee one > two && cmp one two && echo that" "that\n" "" "three"
10 | 


--------------------------------------------------------------------------------
/tests/fallocate.test:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | #testing "name" "command" "result" "infile" "stdin"
4 | 
5 | rm -f foo
6 | testcmd 'simple' '-l 123 foo && stat -c %s foo' '123\n' '' ''
7 | testcmd 'shorter' '-l 12 foo && stat -c %s foo' '123\n' '' ''
8 | testcmd 'longer' '-o 200 -l 12 foo && stat -c %s foo' '212\n' '' ''
9 | 


--------------------------------------------------------------------------------
/tests/files/bc/sqrt.txt:
--------------------------------------------------------------------------------
 1 | scale = 20
 2 | sqrt(0)
 3 | sqrt(2)
 4 | sqrt(4)
 5 | sqrt(9)
 6 | sqrt(16)
 7 | sqrt(25)
 8 | sqrt(121)
 9 | sqrt(48765)
10 | sqrt(9287356207356)
11 | sqrt(0.189274385967238956872354)
12 | sqrt(12389467137496823.134567829387456283946)
13 | sqrt(.0000000000000000000000000000123)
14 | sqrt(1)
15 | 


--------------------------------------------------------------------------------
/tests/ps.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | ln -s "$(which sleep)" xiphoid
 8 | (./xiphoid 5 & echo $! > pid.txt)
 9 | ID=$(cat pid.txt)
10 | NOSPACE=1 testing "" "ps -o pid $ID" "PID\n$ID\n" "" ""
11 | kill "$ID"
12 | 


--------------------------------------------------------------------------------
/toys/net/README:
--------------------------------------------------------------------------------
1 | Networking commands
2 | 
3 | The Internet Engineering Task Force publishes standards drafts at
4 | https://www.ietf.org/rfc/rfc-index.txt (ala https://www.ietf.org/rfc/rfc3.txt)
5 | and the commands tend to be documented in manual page section 8
6 | https://man7.org/linux/man-pages/dir_section_8.html
7 | 


--------------------------------------------------------------------------------
/tests/kill.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testcmd "" "-l HUP" "1\n" "" ""
 8 | testcmd "" "-l 1" "HUP\n" "" ""
 9 | testcmd "" "-l 3 KILL" "QUIT\n9\n" "" ""
10 | testcmd "-0 self" "-0 $$ && echo yes" "yes\n" "" ""
11 | 


--------------------------------------------------------------------------------
/toys/lsb/README:
--------------------------------------------------------------------------------
1 | Linux Standard Base commands
2 | 
3 | Commands defined in the Linux Standard Base 4.1:
4 | http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/cmdbehav.html
5 | 
6 | Downloadable as one big file from:
7 | http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic.html
8 | 


--------------------------------------------------------------------------------
/tests/files/bc/exponent.txt:
--------------------------------------------------------------------------------
 1 | e(0)
 2 | e(0.5)
 3 | e(1)
 4 | e(1.5)
 5 | e(1.74)
 6 | e(2)
 7 | e(3.2345)
 8 | e(5.283957)
 9 | e(13.23857)
10 | e(100)
11 | e(283.238957)
12 | e(-0.5)
13 | e(-1)
14 | e(-1.5)
15 | e(-1.74)
16 | e(-2)
17 | e(-3.2345)
18 | e(-5.283957)
19 | e(-13.23857)
20 | e(-100)
21 | e(-283.238957)
22 | e(142.749502399)
23 | 


--------------------------------------------------------------------------------
/tests/files/bc/log.txt:
--------------------------------------------------------------------------------
 1 | l(0)
 2 | l(0.5)
 3 | l(1)
 4 | l(1.5)
 5 | l(1.74)
 6 | l(2)
 7 | l(3.2345)
 8 | l(5.283957)
 9 | l(13.23857)
10 | l(100)
11 | l(283.238957)
12 | l(-0.5)
13 | l(-1)
14 | l(-1.5)
15 | l(-1.74)
16 | l(-2)
17 | l(-3.2345)
18 | l(-5.283957)
19 | l(-13.23857)
20 | l(-100)
21 | l(-283.238957)
22 | l(10430710.3325472917)
23 | 


--------------------------------------------------------------------------------
/scripts/probes/GLOBALS:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | # Show bytes used by each command's GLOBALS() block, based on last build
4 | {
5 |   echo -e '#include "toys.h"\nint main(void) {'
6 |   sed -n 's/^\tstruct \(.*\)_data .*/printf("%d \1\\n", (int)sizeof(struct \1_data));/p' generated/globals.h
7 |   echo '}'
8 | } | "${CROSS_COMPILE}"cc -xc - && ./a.out | sort -n
9 | 


--------------------------------------------------------------------------------
/tests/tsort.test:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | #testing "name" "command" "result" "infile" "stdin"
4 | 
5 | testcmd 'simple' '' 'a\nb\nc\nd\n' '' 'a b b c c d\n'
6 | testcmd 'reversed' '' 'a\nb\nc\nd\n' '' 'c d b c a b'
7 | testcmd '2 pass duplicate killing' '' 'c\nf\na\n' '' 'f a c f'
8 | testcmd 'detect cycle' '>/dev/null 2>/dev/null || echo yes' 'yes\n' '' 'a b b a'
9 | 


--------------------------------------------------------------------------------
/scripts/probes/findglobals:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | # Quick and dirty check to see if anybody's leaked global variables.
4 | # We should have this, toy_list, toybuf, libbuf, toys, and toybox_version.
5 | 
6 | nm --size-sort generated/unstripped/toybox | grep '[0-9A-Fa-f]* [BCDGRS]' | \
7 |   grep -v GLIBC | while read a b c; do printf '%s %d\t%s\n' $b 0x$a $c; done | \
8 |   sort -k2,2n
9 | 


--------------------------------------------------------------------------------
/toys/other/clear.c:
--------------------------------------------------------------------------------
 1 | /* clear.c - clear the screen
 2 |  *
 3 |  * Copyright 2012 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_CLEAR(NEWTOY(clear, NULL, TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config CLEAR
 8 |   bool "clear"
 9 |   default y
10 |   help
11 |     Clear the screen.
12 | */
13 | 
14 | #include "toys.h"
15 | 
16 | void clear_main(void)
17 | {
18 |   printf("\e[2J\e[H");
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/files/bc/sqrt_results.txt:
--------------------------------------------------------------------------------
 1 | 0
 2 | 1.41421356237309504880
 3 | 2.00000000000000000000
 4 | 3.00000000000000000000
 5 | 4.00000000000000000000
 6 | 5.00000000000000000000
 7 | 11.00000000000000000000
 8 | 220.82798735667542192643
 9 | 3047516.39985021245496456781
10 | .435056761776252544285578
11 | 111307983.260397019622398608908
12 | .0000000000000035071355833500363
13 | 1.00000000000000000000
14 | 


--------------------------------------------------------------------------------
/tests/uptime.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "uptime" "uptime | grep -q 'load average:' && echo t" "t\n" "" ""
 8 | testing "uptime -s" \
 9 |         "uptime -s | grep -q '^[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] [0-9][0-9]:[0-9][0-9]:[0-9][0-9]$' && echo t" \
10 |         "t\n" "" ""
11 | 


--------------------------------------------------------------------------------
/tests/hostname.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | HOST="$(cat /proc/sys/kernel/hostname 2>/dev/null)"
 8 | skipnot [ $? -eq 0 ]
 9 | testing "get" "hostname" "$HOST\n" "" ""
10 | 
11 | skipnot [ $(id -u) -eq 0 ]
12 | testing "set" 'hostname "2>&1 | tee"; hostname; hostname "$HOST"' "2>&1 | tee\n" "" ""
13 | 


--------------------------------------------------------------------------------
/tests/netcat.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | { dd if=/dev/zero bs=4k count=1 2>/dev/null | tr '\0' a; echo b; } > testfile
 8 | testing "more than buffer bytes left at end" \
 9 |   "netcat -lp 1234 wc -c & sleep .1 && cat testfile | netcat 127.0.0.1 1234" \
10 |   "4098\n" "" ""
11 | rm -f testfile
12 | 


--------------------------------------------------------------------------------
/tests/files/bc/script.sh:
--------------------------------------------------------------------------------
 1 | #! /bin/sh
 2 | 
 3 | if [ "$#" -lt 4 ]; then
 4 | 	echo "usage: script.sh <bc> <test_output1> <test_output2> <script>"
 5 | 	exit 1
 6 | fi
 7 | 
 8 | set -e
 9 | 
10 | bc="$1"
11 | shift
12 | 
13 | out1="$1"
14 | shift
15 | 
16 | out2="$1"
17 | shift
18 | 
19 | script="$1"
20 | 
21 | echo "quit" | bc -lq "$script" > "$out1"
22 | echo "quit" | "$bc" -lq "$script" > "$out2"
23 | 
24 | diff "$out1" "$out2"
25 | 


--------------------------------------------------------------------------------
/www/downloads/binaries/toolchains/README:
--------------------------------------------------------------------------------
1 | These toolchains were built with musl-cross-make.tar.xz, which includes
2 | all the source tarballs. Run ./mcm-buildall.sh to reproduce them in the
3 | "ccc" subdirectory. See https://landley.net/toybox/faq.html#cross2
4 | for details.
5 | 
6 | The native-compiler.sqf files are loopback mountable squashfs filesystems.
7 | 
8 | Currently built from: musl 1.2.3, linux 5.17, gcc 9.4.0, binutils 2.33.1
9 | 


--------------------------------------------------------------------------------
/tests/README.txt:
--------------------------------------------------------------------------------
1 | The build infrastructure adds a "make test_NAME" target for each NAME.test
2 | file in this directory, and "make tests" iterates through all of them.
3 | 
4 | Individual tests boil down to a call to "scripts/test.sh NAME", and
5 | testing all is "scripts/test.sh" with no arguments.
6 | 
7 | The test infrastructure, including the shell functions each test calls
8 | (mostly "testcmd" and "optional") is described in scripts/test.sh
9 | 


--------------------------------------------------------------------------------
/tests/dirname.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "/-only" "dirname ///////" "/\n" "" ""
 8 | testing "trailing /" "dirname a//////" ".\n" "" ""
 9 | testing "combined" "dirname /////a///b///c///d/////" "/////a///b///c\n" "" ""
10 | testing "/a/" "dirname /////a///" "/\n" "" ""
11 | testing "multiple" "dirname hello/a world/b" "hello\nworld\n" "" ""
12 | 


--------------------------------------------------------------------------------
/tests/files/bc/misc1_results.txt:
--------------------------------------------------------------------------------
 1 | 2
 2 | 3
 3 | 0
 4 | 10
 5 | 10
 6 | 7
 7 | 10
 8 | -1
 9 | 642
10 | 8
11 | 2
12 | 2
13 | 11
14 | 4
15 | 3
16 | 1
17 | 2
18 | 3
19 | 0
20 | 10
21 | 10
22 | 7
23 | 10
24 | -1
25 | 642
26 | 8
27 | 2
28 | 2
29 | 11
30 | 4
31 | 3
32 | 1
33 | 0
34 | 10
35 | 110
36 | 100
37 | 1000
38 | 10
39 | 10000000000
40 | 100000
41 | 3
42 | 3
43 | 5
44 | 11
45 | 10
46 | 10
47 | 10
48 | 11
49 | 10
50 | 10
51 | 100
52 | 150
53 | 1
54 | 0
55 | 0
56 | 0
57 | 5
58 | 


--------------------------------------------------------------------------------
/tests/more.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | cat >file1 <<EOF
 8 | line1
 9 | line2
10 | EOF
11 | 
12 | # For non-tty output, headers are shown even if there's only one file.
13 | testing "non-tty" "more file1 | cat -" "::::::::::::::\nfile1\n::::::::::::::\nline1\nline2\n" "" ""
14 | 
15 | testing "directory" "more ." "\n*** .: directory ***\n\n" "" ""
16 | 
17 | rm file1
18 | 


--------------------------------------------------------------------------------
/www/downloads/binaries/mkroot/README:
--------------------------------------------------------------------------------
 1 | Bootable system images created by scripts/mkroot.sh:
 2 | 
 3 |   LINUX=~/linux CROSS=allnonstop scripts/mkroot.sh
 4 | 
 5 | Each system image is built from two packages: toybox and Linux.
 6 | Run the ./qemu-*.sh script in the tarball to boot the system
 7 | to a shell prompt under qemu. Run the "exit" command to shut down the
 8 | virtual system and exit the emulator.
 9 | 
10 | See https://landley.net/toybox/FAQ.html#mkroot for details.
11 | 


--------------------------------------------------------------------------------
/tests/comm.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | echo -e 'a\nb\nc'> lhs
 8 | for i in c d e ; do echo $i >> rhs ; done
 9 | testing "comm" "comm lhs input" "a\nb\n\t\tc\n\td\n\te\n" "c\nd\ne\n" ""
10 | testing "comm -" "comm - input" "a\nb\n\t\tc\n\td\n\te\n" "c\nd\ne\n" "a\nb\nc\n"
11 | testing "comm -123 detects missing" "comm - missing 2>/dev/null || echo here" \
12 |   "here\n" "" ""
13 | 


--------------------------------------------------------------------------------
/toys/other/README:
--------------------------------------------------------------------------------
 1 | Other commands
 2 | 
 3 | These are commands not present in Posix or LSB.
 4 | 
 5 | Most of them are necessary to provide a development environment capable of
 6 | booting a system image and building Linux From Scratch under it.
 7 | 
 8 | Tested with Aboriginal Linux system image and the lfs-bootstrap.hdc automated
 9 | build control image for Linux From Scratch 6.8):
10 | 
11 |   http://landley.net/aboriginal
12 | 
13 |   http://landley.net/aboriginal/control-images
14 | 


--------------------------------------------------------------------------------
/tests/tr.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "" "tr 1 2" "223223223" "" "123123123"
 8 | testing "-d" "tr -d 1" "232323" "" "123123123"
 9 | testing "-s" "tr -s 1" "12223331222333" "" "111222333111222333"
10 | testing "-t" "tr -t 1234 567" "5674" "" "1234"
11 | testing "-t one arg" "tr -t 1234" "1234" "" "1234"
12 | 
13 | testing "no pathological flushing" "seq 10000000 | tr 1 2 > /dev/null" "" "" ""
14 | 


--------------------------------------------------------------------------------
/toys/posix/false.c:
--------------------------------------------------------------------------------
 1 | /* false.c - Return nonzero.
 2 |  *
 3 |  * Copyright 2007 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/false.html
 6 | 
 7 | USE_FALSE(NEWTOY(false, NULL, TOYFLAG_BIN|TOYFLAG_NOHELP|TOYFLAG_MAYFORK))
 8 | 
 9 | config FALSE
10 |   bool "false"
11 |   default y
12 |   help
13 |     usage: false
14 | 
15 |     Return nonzero.
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void false_main(void)
21 | {
22 |   toys.exitval = 1;
23 | }
24 | 


--------------------------------------------------------------------------------
/tests/httpd.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testcmd "static file" \
 8 |   "\"\$FILES\" | sed 's/\\r//g;1,/^\$/d'>file; cmp file \$FILES/tar/tar.tar && echo yes" \
 9 |   'yes\n' '' 'GET /tar/tar.tar HTTP/1.1\r\n\r\n' 
10 | rm -f file
11 | 
12 | testcmd "mime type" \
13 |   '"$FILES" | tr A-Z a-z | sed -n "s/\r//g;s/^content-type: //p"' "application/x-tar\n" "" \
14 |   'GET /tar/tar.tar HTTP/1.1\r\n\r\n' 
15 | 
16 | 


--------------------------------------------------------------------------------
/toys/posix/true.c:
--------------------------------------------------------------------------------
 1 | /* true.c - Return zero.
 2 |  *
 3 |  * Copyright 2007 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/true.html
 6 | 
 7 | USE_TRUE(NEWTOY(true, NULL, TOYFLAG_BIN|TOYFLAG_NOHELP|TOYFLAG_MAYFORK))
 8 | USE_TRUE(OLDTOY(:, true, TOYFLAG_NOFORK|TOYFLAG_NOHELP))
 9 | 
10 | config TRUE
11 |   bool "true"
12 |   default y
13 |   help
14 |     usage: true
15 | 
16 |     Return zero.
17 | */
18 | 
19 | #include "toys.h"
20 | 
21 | void true_main(void)
22 | {
23 |   return;
24 | }
25 | 


--------------------------------------------------------------------------------
/toys/lsb/sync.c:
--------------------------------------------------------------------------------
 1 | /* sync.c - Write all pending data to disk.
 2 |  *
 3 |  * Copyright 2007 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/sync.html
 6 | 
 7 | USE_SYNC(NEWTOY(sync, NULL, TOYFLAG_BIN))
 8 | 
 9 | config SYNC
10 |   bool "sync"
11 |   default y
12 |   help
13 |     usage: sync
14 | 
15 |     Write pending cached data to disk (synchronize), blocking until done.
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void sync_main(void)
21 | {
22 |   sync();
23 | }
24 | 


--------------------------------------------------------------------------------
/scripts/change.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # build each command as a standalone executable
 4 | 
 5 | source scripts/portability.sh
 6 | 
 7 | NOBUILD=1 scripts/make.sh > /dev/null &&
 8 | ${HOSTCC:-cc} -I . scripts/install.c -o "$UNSTRIPPED"/instlist &&
 9 | export PREFIX=${PREFIX:-change/} &&
10 | mkdir -p "$PREFIX" || exit 1
11 | 
12 | # Build all the commands standalone
13 | for i in $("$UNSTRIPPED"/instlist)
14 | do
15 |   echo -n " $i" &&
16 |   scripts/single.sh $i &>$PREFIX/${i}.bad &&
17 |     rm $PREFIX/${i}.bad || echo -n '*'
18 | done
19 | echo
20 | 


--------------------------------------------------------------------------------
/toys/other/nologin.c:
--------------------------------------------------------------------------------
 1 | /* nologin.c - False with a message.
 2 |  *
 3 |  * Copyright 2025 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * No standard.
 6 | 
 7 | USE_NOLOGIN(NEWTOY(nologin, 0, TOYFLAG_BIN|TOYFLAG_NOHELP))
 8 | 
 9 | config NOLOGIN
10 |   bool "nologin"
11 |   default y
12 |   help
13 |     usage: nologin
14 | 
15 |     Print /etc/nologin.txt and return failure.
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void nologin_main(void)
21 | {
22 |   toys.exitval = 1;
23 |   puts(readfile("/etc/nologin.txt", 0, 0) ? : toys.which->name);
24 | }
25 | 


--------------------------------------------------------------------------------
/toys/posix/unlink.c:
--------------------------------------------------------------------------------
 1 | /* unlink.c - delete one file
 2 |  *
 3 |  * Copyright 2011 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/unlink.html
 6 | 
 7 | USE_UNLINK(NEWTOY(unlink, "<1>1", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config UNLINK
10 |   bool "unlink"
11 |   default y
12 |   help
13 |     usage: unlink FILE
14 | 
15 |     Delete one file.
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void unlink_main(void)
21 | {
22 |   if (unlink(*toys.optargs))
23 |     perror_exit("couldn't unlink '%s'", *toys.optargs);
24 | }
25 | 


--------------------------------------------------------------------------------
/tests/bzcat.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | testing "2 known files" \
 7 |  'bzcat "$FILES/blkid/"{minix,ntfs}.bz2 | sha1sum | cut -d " " -f 1' \
 8 |  'c0b7469c9660d6056a988ef8a7fe73925efc9266\n' '' ''
 9 | 
10 | testing "overflow" \
11 |   'bzcat "$FILES/bzcat/overflow.bz2" >/dev/null 2>/dev/null ;
12 |    [ $? -ne 0 ] && echo good' "good\n" "" ""
13 | 
14 | testing "badcrc" \
15 |   'bzcat "$FILES/bzcat/badcrc.bz2" > /dev/null 2>/dev/null ;
16 |    [ $? -ne 0 ] && echo good' "good\n" "" ""
17 | 


--------------------------------------------------------------------------------
/toys/other/uuidgen.c:
--------------------------------------------------------------------------------
 1 | /* uuidgen.c - Create a new random UUID
 2 |  *
 3 |  * Copyright 2018 The Android Open Source Project
 4 |  *
 5 |  * UUID RFC: https://tools.ietf.org/html/rfc4122
 6 | 
 7 | USE_UUIDGEN(NEWTOY(uuidgen, ">0r(random)", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config UUIDGEN
10 |   bool "uuidgen"
11 |   default y
12 |   help
13 |     usage: uuidgen
14 | 
15 |     Create and print a new RFC4122 random UUID.
16 | */
17 | 
18 | #define FOR_uuidgen
19 | #include "toys.h"
20 | 
21 | void uuidgen_main(void)
22 | {
23 |   create_uuid(toybuf);
24 |   puts(show_uuid(toybuf));
25 | }
26 | 


--------------------------------------------------------------------------------
/tests/files/bc/vars_results.txt:
--------------------------------------------------------------------------------
 1 | 1609746610419572350599.59456175545
 2 | .0000772397688552681359718594121969204138521230712049526233926741658\
 3 | 845368495051158801794834809672994
 4 | 34895734996363239667509709873808371507.68195580850970988421481133834\
 5 | 5
 6 | 246246247.226719697748
 7 | -28914376850.99973314416
 8 | .0030975704827179453786044330548590249517387192084765414205077089498\
 9 | 482709063381782183114683451531598
10 | 78562139406792834691802347619083467219846713490861872324967134906218\
11 | 73468982410934861390461390846134908173560238718691027461827490618726\
12 | 09129847
13 | 


--------------------------------------------------------------------------------
/mkroot/packages/tests:
--------------------------------------------------------------------------------
 1 | #!/bin/echo Try "mkroot/mkroot.sh $0"
 2 | 
 3 | # Alas http://www.linux-usb.org/usb.ids is not versioned, so...
 4 | download 36d4e16755502fbc684be75e56841e1014e4a94a \
 5 |   https://github.com/usbids/usbids/raw/a5edeafb6099/usb.ids
 6 | 
 7 | # Nor is https://pci-ids.ucw.cz/v2.2/pci.ids (tool version, not file version)
 8 | download 6694284723e034f0c564e81a30879939d5ef8b7e \
 9 |   https://github.com/pciutils/pciids/raw/c7929c0f9480/pci.ids
10 | 
11 | cp "$DOWNLOAD"/{usb,pci}.ids "$ROOT/etc/" || exit 1
12 | 
13 | # add a couple test modules
14 | MODULES+=FSCACHE,CACHEFILES
15 | 


--------------------------------------------------------------------------------
/toys/other/freeramdisk.c:
--------------------------------------------------------------------------------
 1 | /* freeramdisk.c - Free all memory allocated to ramdisk
 2 |  *
 3 |  * Copyright 2014 Vivek Kumar Bhagat <vivek.bhagat89@gmail.com>
 4 |  *
 5 |  * No Standard
 6 | 
 7 | USE_FREERAMDISK(NEWTOY(freeramdisk, "<1>1", TOYFLAG_SBIN|TOYFLAG_NEEDROOT))
 8 | 
 9 | config FREERAMDISK
10 |   bool "freeramdisk"
11 |   default y
12 |   help
13 |     usage: freeramdisk [RAM device]
14 | 
15 |     Free all memory allocated to specified ramdisk
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void freeramdisk_main(void)
21 | {
22 |   xioctl(xopen(*toys.optargs, O_RDWR), BLKFLSBUF, 0);
23 | }
24 | 


--------------------------------------------------------------------------------
/toys/posix/dirname.c:
--------------------------------------------------------------------------------
 1 | /* dirname.c - show directory portion of path
 2 |  *
 3 |  * Copyright 2011 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/dirname.html
 6 | 
 7 | USE_DIRNAME(NEWTOY(dirname, "<1", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config DIRNAME
10 |   bool "dirname"
11 |   default y
12 |   help
13 |     usage: dirname PATH...
14 | 
15 |     Show directory portion of path.
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void dirname_main(void)
21 | {
22 |   char **arg;
23 | 
24 |   for (arg = toys.optargs; *arg; ++arg) puts(dirname(*arg));
25 | }
26 | 


--------------------------------------------------------------------------------
/toys/posix/link.c:
--------------------------------------------------------------------------------
 1 | /* link.c - hardlink a file
 2 |  *
 3 |  * Copyright 2011 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/link.html
 6 | 
 7 | USE_LINK(NEWTOY(link, "<2>2", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config LINK
10 |   bool "link"
11 |   default y
12 |   help
13 |     usage: link FILE NEWLINK
14 | 
15 |     Create hardlink to a file.
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void link_main(void)
21 | {
22 |   if (link(toys.optargs[0], toys.optargs[1]))
23 |     perror_exit("couldn't link '%s' to '%s'", toys.optargs[1],
24 |       toys.optargs[0]);
25 | }
26 | 


--------------------------------------------------------------------------------
/toys/other/usleep.c:
--------------------------------------------------------------------------------
 1 | /* usleep.c - Wait for a number of microseconds.
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | USE_USLEEP(NEWTOY(usleep, "<1>1", TOYFLAG_BIN))
 6 | 
 7 | config USLEEP
 8 |   bool "usleep"
 9 |   default y
10 |   help
11 |     usage: usleep MICROSECONDS
12 | 
13 |     Pause for MICROSECONDS microseconds.
14 | */
15 | 
16 | #include "toys.h"
17 | 
18 | void usleep_main(void)
19 | {
20 |   struct timespec tv;
21 |   long delay = atol(*toys.optargs);
22 | 
23 |   tv.tv_sec = delay/1000000;
24 |   tv.tv_nsec = (delay%1000000) * 1000;
25 |   toys.exitval = !!nanosleep(&tv, NULL);
26 | }
27 | 


--------------------------------------------------------------------------------
/tests/top.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "batch termination" "top -b -n1 | tail -c 1" "\n" "" ""
 8 | testing "fractional seconds" "top -b -d 8.5 -n1 | tail -c 1" "\n" "" ""
 9 | 
10 | # These are unit tests of xparsetime.
11 | testing "-d invalid input" "top -b -d monkey -n1 2>&1 >/dev/null" "top: Not a number 'monkey'\n" "" ""
12 | testing "-d unknown suffix" "top -b -d 1u -n1 2>&1 >/dev/null" "top: Unknown suffix 'u'\n" "" ""
13 | testing "-d suffix trailing junk" "top -b -d 1monkey -n1 2>&1 >/dev/null" "top: Unknown suffix 'monkey'\n" "" ""
14 | 


--------------------------------------------------------------------------------
/toys/other/fsfreeze.c:
--------------------------------------------------------------------------------
 1 | /* fsfreeze.c - freeze or thaw filesystem
 2 |  *
 3 |  * No standard.
 4 | 
 5 | USE_FSFREEZE(NEWTOY(fsfreeze, "<1>1f|u|[!fu]", TOYFLAG_USR|TOYFLAG_SBIN))
 6 | 
 7 | config FSFREEZE
 8 |   bool "fsfreeze"
 9 |   default y
10 |   help
11 |     usage: fsfreeze {-f | -u} MOUNTPOINT
12 | 
13 |     Freeze or unfreeze a filesystem.
14 | 
15 |     -f	Freeze
16 |     -u	Unfreeze
17 | */
18 | 
19 | #define FOR_fsfreeze
20 | #include "toys.h"
21 | #include <linux/fs.h>
22 | 
23 | void fsfreeze_main(void)
24 | {
25 |   int fd = xopenro(*toys.optargs);
26 |   long p = 1;
27 | 
28 |   xioctl(fd, FLAG(f) ? FIFREEZE : FITHAW, &p);
29 |   xclose(fd);
30 | }
31 | 


--------------------------------------------------------------------------------
/mkroot/README.root:
--------------------------------------------------------------------------------
 1 | Use ./run-qemu.sh to boot system image to a shell prompt, "exit" when done.
 2 | 
 3 | Additional arguments to run-qemu.sh are QEMU arguments,
 4 | $KARGS contains additional linux kernel arguments. For example:
 5 | 
 6 |   KARGS=quiet ./run-qemu.sh -hda docs/linux-fullconfig
 7 |   # cat /dev/?da
 8 |   # exit
 9 | 
10 | To extract the root filesystem from cpio.gz and chroot into it
11 | 
12 |   ( mkdir fs && cd fs && zcat ../initramfs.cpio.gz | cpio -i -d -H newc )
13 |   chroot fs /init
14 | 
15 | To recreate the initramfs.cpio.gz from fs directory
16 | 
17 |   ( cd fs && find . -printf '%P\n' | cpio -o -H newc -R +0:+0 | gzip ) \
18 |     > initramfs.cpio.gz
19 | 


--------------------------------------------------------------------------------
/toys/example/demo_many_options.c:
--------------------------------------------------------------------------------
 1 | /* demo_many_options.c - test more than 32 bits worth of option flags
 2 |  *
 3 |  * Copyright 2015 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_DEMO_MANY_OPTIONS(NEWTOY(demo_many_options, "ZYXWVUTSRQPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfedcba", TOYFLAG_BIN))
 6 | 
 7 | config DEMO_MANY_OPTIONS
 8 |   bool "demo_many_options"
 9 |   default n
10 |   help
11 |     usage: demo_many_options -[a-zA-Z]
12 | 
13 |     Print the optflags value of the command arguments, in hex.
14 | */
15 | 
16 | #define FOR_demo_many_options
17 | #include "toys.h"
18 | 
19 | void demo_many_options_main(void)
20 | {
21 |   xprintf("optflags=%llx\n", toys.optflags);
22 | }
23 | 


--------------------------------------------------------------------------------
/toys/other/linux32.c:
--------------------------------------------------------------------------------
 1 | /* linux32.c - Change uname -m output, and on some architectures /proc/cpuinfo
 2 |  *
 3 |  * Copyright 2023 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * No standard: it's a syscall wrapper provided by util-linux.
 6 | 
 7 | USE_LINUX32(NEWTOY(linux32, 0, TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config LINUX32
10 |   bool "linux32"
11 |   default y
12 |   help
13 |     usage: linux32 [COMMAND...]
14 | 
15 |     Tell uname -m to lie to autoconf (to build 32 bit binaries on 64 bit kernel).
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void linux32_main(void)
21 | {
22 |   personality(PER_LINUX32);
23 |   xexec(toys.optc ? toys.optargs : (char *[]){"/bin/sh", 0});
24 | }
25 | 


--------------------------------------------------------------------------------
/scripts/probes/showasm:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | # Copyright 2006 Rob Landley <rob@landley.net>
 4 | 
 5 | # Dumb little utility function to print out the assembly dump of a single
 6 | # function, or list the functions so dumpable in an executable.  You'd think
 7 | # there would be a way to get objdump to do this, but I can't find it.
 8 | 
 9 | [ $# -lt 1 ] || [ $# -gt 2 ] && { echo "usage: showasm file function"; exit 1; }
10 | 
11 | [ ! -f $1 ] && { echo "File $1 not found"; exit 1; }
12 | 
13 | if [ $# -eq 1 ]
14 | then
15 |   objdump -d $1 | sed -n -e 's/^[0-9a-fA-F]* <\(.*\)>:$/\1/p'
16 |   exit 0
17 | fi
18 | 
19 | objdump -d $1 | sed -n -e '/./{H;$!d}' -e "x;/^.[0-9a-fA-F]* <$2>:/p"
20 | 
21 | 


--------------------------------------------------------------------------------
/tests/files/bc/vars.txt:
--------------------------------------------------------------------------------
1 | scale=10;123981239.981273987 * 12983791827398.29836472638
2 | scale=100;759634576394.3946587934658364895 / 9834759834895386.36459364958346
3 | 34895734986539489834759837489573498573.398475984759837485734987598345 + 9823749832749872384234872934.28347982374987239847982374
4 | a=123123123.987239874; b=123123123.239479823748; a+b
5 | 20347023.23498723984 - 28934723874.234720384
6 | scale=100;a=739534985.895347284957;b=238746782364.2374623784; c = a / b; c
7 | s7298367203972395108367910823465293084561329084561390845613409516734503870691837451 + 785621394067928346918023476190834672198467134908618723249671349062187346898241093486139046139084613490817356023871869102746182749061872609129847
8 | 


--------------------------------------------------------------------------------
/tests/zcat.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | echo -n "hi " | gzip > 1.gz
 8 | echo "there" | gzip > 2.gz
 9 | 
10 | # zcat is basically just gzip -dc
11 | testcmd "files" "1.gz 2.gz && test -f 1.gz && test -f 2.gz" "hi there\n" "" ""
12 | # zcat -c is allowed but changes nothing
13 | testcmd "-c" "-c 1.gz 2.gz && test -f 1.gz && test -f 2.gz" "hi there\n" "" ""
14 | testing "concatenated" "{ cat 1.gz 2.gz; } | zcat" "hi there\n" "" ""
15 | testing "error" "head -c 10 2.gz | { zcat 2>/dev/null || echo fail; }" "fail\n"\
16 |   "" ""
17 | 
18 | # TODO: how to test "zcat -f"?
19 | 
20 | rm -f 1 2 1.gz 2.gz
21 | 


--------------------------------------------------------------------------------
/toys/posix/tty.c:
--------------------------------------------------------------------------------
 1 | /* tty.c - Show stdin's terminal name
 2 |  *
 3 |  * Copyright 2011 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/tty.html
 6 | 
 7 | USE_TTY(NEWTOY(tty, "s", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config TTY
10 |   bool "tty"
11 |   default y
12 |   help
13 |     usage: tty [-s]
14 | 
15 |     Show filename of terminal connected to stdin. If none print "not a tty"
16 |     and exit with nonzero status.
17 | 
18 |     -s	Silent, exit code only
19 | */
20 | 
21 | #include "toys.h"
22 | 
23 | void tty_main(void)
24 | {
25 |   char *tty = ttyname(0);
26 | 
27 |   toys.exitval = !tty;
28 |   if (!toys.optflags) puts(tty ? : "not a tty");
29 | }
30 | 


--------------------------------------------------------------------------------
/toys/example/hostid.c:
--------------------------------------------------------------------------------
 1 | /* hostid.c - Print the numeric identifier for the current host.
 2 |  *
 3 |  * Copyright 2015 Ranjan Kumar <ranjankumar.bth@gmail.com>
 4 |  *
 5 |  * No Standard.
 6 |  *
 7 |  * This is still in coreutils and gethostid() in posix, but a "globally unique
 8 |  * 32 bit identifier" is a concept the Linux world has outgrown.
 9 | 
10 | USE_HOSTID(NEWTOY(hostid, ">0", TOYFLAG_USR|TOYFLAG_BIN))
11 | 
12 | config HOSTID
13 |   bool "hostid"
14 |   default n
15 |   help
16 |     usage: hostid
17 | 
18 |     Print the numeric identifier for the current host.
19 | */
20 | #define FOR_hostid
21 | #include "toys.h"
22 | 
23 | void hostid_main(void)
24 | {
25 |   xprintf("%08lx\n", gethostid());
26 | }
27 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (C) 2006, 2019 by Rob Landley <rob@landley.net>
 2 | 
 3 | Permission to use, copy, modify, and/or distribute this software for any
 4 | purpose with or without fee is hereby granted.
 5 | 
 6 | THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 7 | WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 8 | MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 9 | ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
10 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
11 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
12 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
13 | 


--------------------------------------------------------------------------------
/toys/android/runcon.c:
--------------------------------------------------------------------------------
 1 | /* runcon.c - Run command in specified security context
 2 |  *
 3 |  * Copyright 2015 The Android Open Source Project
 4 | 
 5 | USE_RUNCON(NEWTOY(runcon, "^<2", TOYFLAG_USR|TOYFLAG_SBIN))
 6 | 
 7 | config RUNCON
 8 |   bool "runcon"
 9 |   depends on TOYBOX_SELINUX
10 |   default y
11 |   help
12 |     usage: runcon CONTEXT COMMAND [ARGS...]
13 | 
14 |     Run a command in a specified security context.
15 | */
16 | 
17 | #define FOR_runcon
18 | #include "toys.h"
19 | 
20 | void runcon_main(void)
21 | {
22 |   char *context = *toys.optargs;
23 | 
24 |   if (setexeccon(context)) perror_exit("Could not set context to %s", context);
25 | 
26 |   toys.stacktop = 0;
27 |   xexec(++toys.optargs);
28 | }
29 | 


--------------------------------------------------------------------------------
/mkroot/packages/dynamic:
--------------------------------------------------------------------------------
 1 | #!/bin/echo Try "mkroot/mkroot.sh dynamic"
 2 | 
 3 | # Copy dynamic libraries from cross compiler
 4 | 
 5 | "${CROSS_COMPILE}cc" -xc - <<< 'void main(void) {;}' ||
 6 |   die "${CROSS_COMPILE}cc can't create dynamic binaries"
 7 | LDSO="$("${CROSS_COMPILE}readelf" -a a.out | sed -n 's/.*interpreter: \([^]]*\)[]]$/\1/p')"
 8 | mkdir -p "$ROOT"/"$(dirname "$LDSO")" &&
 9 |   cp "$LDSO" "$ROOT"/"$LDSO" || die "Couldn't copy ldso"
10 | unset LDSO
11 | 
12 | "${CROSS_COMPILE}cc" -print-search-dirs | sed -n 's/libraries: =//p' | \
13 |   tr : '\n' | while read i; do
14 |     [ -e "$i" ] && find "$i" -maxdepth 1 -name '*.so' -o -name '*.so*[0-9]'
15 |   done | while read i; do cp -a "$i" "$ROOT"/lib/; done
16 | 


--------------------------------------------------------------------------------
/tests/files/bc/cosine.txt:
--------------------------------------------------------------------------------
 1 | scale = 25
 2 | p = 4 * a(1)
 3 | scale = 20
 4 | c(0)
 5 | c(0.5)
 6 | c(1)
 7 | c(2)
 8 | c(3)
 9 | c(-0.5)
10 | c(-1)
11 | c(-2)
12 | c(-3)
13 | c(p / 7)
14 | c(-p / 7)
15 | c(p / 4)
16 | c(-p / 4)
17 | c(p / 3)
18 | c(-p / 3)
19 | c(p / 2)
20 | c(-p / 2)
21 | c(3 * p / 4)
22 | c(3 * -p / 4)
23 | c(p)
24 | c(-p)
25 | c(3 * p / 2)
26 | c(3 * -p / 2)
27 | c(7 * p / 4)
28 | c(7 * -p / 4)
29 | c(13 * p / 4)
30 | c(13 * -p / 4)
31 | c(2 * p)
32 | c(2 * -p)
33 | c(131231)
34 | c(-131231)
35 | c(859799894.3562378245)
36 | c(859799894.3562378245)
37 | c(4307371)
38 | c(3522556.3323810191)
39 | c(44961070)
40 | c(6918619.1574479809)
41 | c(190836996.2180244164)
42 | c(34934)
43 | c(2483599)
44 | c(13720376)
45 | 


--------------------------------------------------------------------------------
/tests/files/bc/misc2.txt:
--------------------------------------------------------------------------------
 1 | define x() {
 2 | "x"
 3 | return ( 1 )
 4 | }
 5 | define y() {
 6 | "y"
 7 | return (2)
 8 | }
 9 | define z() {
10 | "z"
11 | return (3)
12 | }
13 | 
14 | if ( x() == y() ) {1}
15 | 1
16 | if ( x() <= y() ) {2}
17 | if ( y() >= x() ) {3}
18 | if ( x() != y() ) {4}
19 | if ( x() < y() ) {5}
20 | if ( y() > x() ) {6}
21 | 
22 | if ( x() == z() ) {11}
23 | 11
24 | if ( x() <= z() ) {12}
25 | if ( z() >= x() ) {13}
26 | if ( x() != z() ) {14}
27 | if ( x() < z() ) {15}
28 | if ( z() > x() ) {16}
29 | 
30 | x = -10
31 | while (x <= 0) {
32 | 	x
33 | 	if (x == -5) break;
34 | 	x += 1
35 | }
36 | 
37 | define u() {
38 | 	auto a[];
39 | 	return a[0]
40 | }
41 | 
42 | u()
43 | 
44 | if (x == -4) x
45 | else x - 4
46 | 


--------------------------------------------------------------------------------
/tests/killall.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | echo -e "#!$(which sh)\nwhile true; do sleep 0.1; done" > toybox.test
 8 | chmod a+x toybox.test
 9 | cp toybox.test toybox.killall.test.script
10 | 
11 | tst=toybox.test
12 | (./$tst 2>/dev/null &)
13 | testing "short name" "killall -w $tst && echo killed ; sleep 0.1; \
14 |   pgrep -l $tst || echo really" "killed\nreally\n" "" ""
15 | 
16 | tst=toybox.killall.test.script
17 | (./$tst 2>/dev/null &)
18 | testing "long name" "killall -w $tst && echo killed ; sleep 0.1; \
19 |   pgrep -l $tst || echo really" "killed\nreally\n" "" ""
20 | 
21 | rm -f toybox.killall.test.script toybox.test
22 | 


--------------------------------------------------------------------------------
/tests/mkfifo.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "mkfifo" "mkfifo one && [ -p one ] && echo yes" "yes\n" "" ""
 8 | rm one
 9 | 
10 | touch existing
11 | testing "existing" \
12 | 	"mkfifo existing 2> /dev/null || [ -f existing ] && echo yes" "yes\n" "" ""
13 | rm existing
14 | 
15 | testing "one two" \
16 | 	"mkfifo one two && [ -p one ] && [ -p two ] && echo yes" "yes\n" "" ""
17 | rm one two
18 | 
19 | umask 123
20 | testing "(default permissions)" \
21 | 	"mkfifo one && stat -c %a one" "644\n" "" ""
22 | rm one
23 | 
24 | umask 000
25 | 
26 | testing "-m 124" \
27 | 	"mkfifo -m 124 one && stat -c %a one" "124\n" "" ""
28 | rm -f one
29 | 


--------------------------------------------------------------------------------
/tests/fstype.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | BDIR="$FILES/blkid"
 8 | 
 9 | bzcat "$BDIR"/squashfs.bz2 > temp.img
10 | testing "file" "fstype temp.img" 'squashfs\n' "" ""
11 | rm temp.img
12 | 
13 | for i in cramfs ext2 ext3 ext4 f2fs ntfs squashfs vfat xfs
14 | do
15 |   testing "$i" 'bzcat "$BDIR"/$i.bz2 | fstype -' "$i\n" "" ""
16 | done
17 | 
18 | testing "msdos" 'bzcat "$BDIR"/msdos.bz2 | fstype -' 'vfat\n' "" ""
19 | testing "reiserfs" 'bzcat "$BDIR"/reiser3.bz2 | fstype -' 'reiserfs\n' "" ""
20 | 
21 | #testing "blkid minix" 'bzcat "$BDIR"/minix.bz2 | blkid -'
22 | #adfs bfs btrfs cramfs jfs nilfs romfs
23 | #vfat  // fat32 fat12 fat16
24 | 


--------------------------------------------------------------------------------
/tests/stat.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | TZ=utc touch -at 200001010101.01 file
 8 | testcmd "as echo" "-c hello file" "hello\n" "" ""
 9 | testcmd "lone %" "-c % file" "%\n" "" ""
10 | testcmd "%% escapes" "-c '%% and %% then %%' file" "% and % then %\n" "" ""
11 | testcmd "%unknown = ?" "-c %q% file" "?%\n" "" ""
12 | 
13 | TZ=utc testcmd "%x" "-c %x file" "2000-01-01 01:01:01.000000000 +0000\n" "" ""
14 | TZ=utc testcmd "%X" "-c %X file" "946688461\n" "" ""
15 | 
16 | TZ=utc touch -mt 200002020202.02 file
17 | TZ=utc testcmd "%y" "-c %y file" "2000-02-02 02:02:02.000000000 +0000\n" "" ""
18 | TZ=utc testcmd "%Y" "-c %Y file" "949456922\n" "" ""
19 | 


--------------------------------------------------------------------------------
/tests/unicode.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "text" "unicode 안녕 hi" "U+C548 : 안 : 0xec 0x95 0x88\nU+B155 : 녕 : 0xeb 0x85 0x95\nU+0068 : h\nU+0069 : i\n" "" ""
 8 | testing "code points" "unicode 70 666" "U+0070 : p\nU+0666 : ٦ : 0xd9 0xa6\n" "" ""
 9 | testing "ASCII controls" "unicode 0" "U+0000 : NUL\n" "" ""
10 | testing "del" "unicode 7f" "U+007F : DEL\n" "" ""
11 | testing "3-byte" "unicode 30b9" "U+30B9 : ス : 0xe3 0x82 0xb9\n" "" ""
12 | testing "4-byte" "unicode 10000" "U+10000 : 𐀀 : 0xf0 0x90 0x80 0x80\n" "" ""
13 | testing "range" "unicode 660-662" "U+0660 : ٠ : 0xd9 0xa0\nU+0661 : ١ : 0xd9 0xa1\nU+0662 : ٢ : 0xd9 0xa2\n" "" ""
14 | 


--------------------------------------------------------------------------------
/tests/pwd.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | #TODO: Find better tests
 8 | 
 9 | testing "pwd" "[ $(stat -c %i "$(pwd)") = $(stat -c %i .) ] && echo yes" \
10 | 	"yes\n" "" ""
11 | testing "-P" "[ $(stat -c %i "$(pwd -P)") = $(stat -c %i .) ] && echo yes" \
12 | 	"yes\n" "" ""
13 | 
14 | 
15 | ln -s . sym
16 | cd sym
17 | testing "pwd2" "[ $(stat -c %i "$(pwd)") = $(stat -c %i "$PWD") ] && echo yes" \
18 | 	"yes\n" "" ""
19 | testing "-P2" "[ $(stat -c %i "$(pwd -P)") = $(stat -c %i "$PWD") ] || echo yes" \
20 | 	"yes\n" "" ""
21 | cd ..
22 | rm sym
23 | 
24 | export PWD=walrus
25 | testing "(bad PWD)" "[ "$(pwd)" = "$(cd . ; pwd)" ] && echo yes" \
26 | 	"yes\n" "" ""
27 | 


--------------------------------------------------------------------------------
/scripts/probes/cmd2dpkg:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Show debian packages host versions of each command live in
 4 | # (Alas, not as useful as I thought it would be.)
 5 | 
 6 | [ -x toybox ] || { echo "no ./toybox" >&2; exit 1; }
 7 | 
 8 | declare -A ray
 9 | 
10 | # Sad that this is NOT in the default path, but less dumb than /bin/sh->dash
11 | PATH="$PATH":/sbin:/usr/sbin
12 | 
13 | # Only checks installed packages, puts anything it can't find in none:
14 | for i in $(./toybox)
15 | do
16 |   tty -s && echo -n . >&2
17 |   which $i >/dev/null || { ray["none:"]+=" $i"; continue; }
18 | 
19 |   ray[$(dpkg-query -S $(readlink -f $(which $i)) | toybox cut -DF 1)]+=" $i"
20 | done
21 | 
22 | # Print results
23 | for i in ${!ray[@]}
24 | do
25 |   echo $i ${ray[$i]}
26 | done
27 | 


--------------------------------------------------------------------------------
/toys/pending/README:
--------------------------------------------------------------------------------
 1 | Pending (unfinished) commands
 2 | 
 3 | Commands in this directory are external submissions awaiting review and/or
 4 | cleanup before being "promoted" to one of the other directories.
 5 | 
 6 | Code in this directory may or may not work, some of the commands here are
 7 | unfinished stubs, others just need a more thorough inspection than we've had
 8 | time for yet. Everything in here defaults to "n" in defconfig.
 9 | 
10 | Outside of this directory, several commands (and some library code) have
11 | TODO annotations.
12 | 
13 | This directory should go away before the 1.0 release. It's just a staging
14 | area so code submissions don't get lost while awaiting more thorough (and
15 | very time consuming) scrutiny as described in www/cleanup.html.
16 | 


--------------------------------------------------------------------------------
/.github/workflows/toybox.yml:
--------------------------------------------------------------------------------
 1 | name: toybox CI
 2 | 
 3 | on:
 4 |   schedule:
 5 |     - cron:  '0 2 * * *'
 6 |   push:
 7 |     branches: [ master ]
 8 | 
 9 | jobs:
10 |   MacOS-13:
11 |     runs-on: macos-13
12 | 
13 |     steps:
14 |     - uses: actions/checkout@v2
15 |     - name: Setup
16 |       run: brew install gnu-sed
17 |     - name: Configure
18 |       run: make macos_defconfig
19 |     - name: Build
20 |       run: make
21 |     - name: Test
22 |       run: VERBOSE=all make tests
23 | 
24 |   Ubuntu-22_04:
25 |     runs-on: ubuntu-22.04
26 | 
27 |     steps:
28 |     - uses: actions/checkout@v2
29 |     - name: Setup
30 |       run: sudo apt-get install build-essential
31 |     - name: Configure build and test
32 |       run: VERBOSE=all CC=clang make defconfig tests
33 | 


--------------------------------------------------------------------------------
/scripts/prereq/build.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/sh
 2 | 
 3 | BUILD='cc -funsigned-char -I scripts/prereq -I . -Os -ffunction-sections -fdata-sections -fno-asynchronous-unwind-tables -fno-strict-aliasing -DTOYBOX_VERSION=""'
 4 | LINK=''
 5 | FILES="
 6 | main.c toys/lsb/gzip.c toys/other/readlink.c toys/other/which.c 
 7 | toys/pending/tr.c toys/posix/basename.c toys/posix/cat.c toys/posix/chmod.c 
 8 | toys/posix/cmp.c toys/posix/dirname.c toys/posix/echo.c toys/posix/fold.c 
 9 | toys/posix/grep.c toys/posix/head.c toys/posix/ln.c toys/posix/ls.c 
10 | toys/posix/mkdir.c toys/posix/od.c toys/posix/rm.c toys/posix/sed.c 
11 | toys/posix/sort.c toys/posix/tail.c toys/posix/tee.c toys/posix/uname.c 
12 | toys/posix/wc.c toys/posix/xargs.c
13 | "
14 | 
15 | $BUILD lib/*.c $FILES $LINK -o toybox-prereq
16 | 


--------------------------------------------------------------------------------
/toys/android/getenforce.c:
--------------------------------------------------------------------------------
 1 | /* getenforce.c - Get the current SELinux mode
 2 |  *
 3 |  * Copyright 2014 The Android Open Source Project
 4 | 
 5 | USE_GETENFORCE(NEWTOY(getenforce, ">0", TOYFLAG_USR|TOYFLAG_SBIN))
 6 | 
 7 | config GETENFORCE
 8 |   bool "getenforce"
 9 |   default y
10 |   depends on TOYBOX_SELINUX
11 |   help
12 |     usage: getenforce
13 | 
14 |     Shows whether SELinux is disabled, enforcing, or permissive.
15 | */
16 | 
17 | #define FOR_getenforce
18 | #include "toys.h"
19 | 
20 | void getenforce_main(void)
21 | {
22 |   if (!is_selinux_enabled()) puts("Disabled");
23 |   else {
24 |     int ret = security_getenforce();
25 | 
26 |     if (ret == -1) perror_exit("Couldn't get enforcing status");
27 |     else puts(ret ? "Enforcing" : "Permissive");
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/toys/other/w.c:
--------------------------------------------------------------------------------
 1 | /* w.c - shows logged in users
 2 |  *
 3 |  * Copyright 2012 Gaurang Shastri <gmshastri@gmail.com>
 4 | 
 5 | USE_W(NEWTOY(w, NULL, TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config W
 8 |   bool "w"
 9 |   default y
10 |   help
11 |     usage: w
12 | 
13 |     Show who is logged on and since how long they logged in.
14 | */
15 | 
16 | #include "toys.h"
17 | 
18 | void w_main(void)
19 | {
20 |   struct utmpx *x;
21 | 
22 |   xprintf("USER     TTY             LOGIN@              FROM");
23 |   setutxent();
24 |   while ((x=getutxent()) != NULL) {
25 |     if (x->ut_type==7) {
26 |       time_t tt = x->ut_tv.tv_sec;
27 | 
28 |       xprintf("\n%-9.8s%-9.8s %-4.24s (%-1.12s)", x->ut_user, x->ut_line,
29 |         ctime(&tt), x->ut_host);
30 |     }
31 |   }
32 |   xputc('\n');
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/files/bc/power.txt:
--------------------------------------------------------------------------------
 1 | 0 ^ 0
 2 | 0 ^ 1
 3 | 0 ^ 1894
 4 | 1 ^ 0
 5 | 39746823 ^ 0
 6 | 0.238672983047682 ^ 0
 7 | 18394762374689237468.97354862973846 ^ 0
 8 | 1 ^ 1
 9 | 2 ^ 1
10 | 18927361346 ^ 1
11 | 0.23523785962738592635777 ^ 1
12 | 328956734869213746.89782398457234 ^ 1
13 | 8937 ^ 98
14 | 0.124876812394 ^ 96
15 | 93762.2836 ^ 13
16 | 1 ^ -1
17 | 2 ^ -1
18 | 10 ^ -1
19 | 683734768 ^ -1
20 | 38579623756.897937568235 ^ -1
21 | 1 ^ -32467
22 | 2 ^ -53
23 | 23897 ^ -3
24 | -1 ^ 1
25 | -1 ^ 2
26 | -2 ^ 1
27 | -2 ^ 2
28 | -237 ^ 29
29 | -3746 ^ 8
30 | -0.3548 ^ 35
31 | -4267.234 ^ 7
32 | -326.3246 ^ 8
33 | -1 ^ -1
34 | -1 ^ -2
35 | -2 ^ -1
36 | -2 ^ -2
37 | -237 ^ -93
38 | -784 ^ -23
39 | -86 ^ -7
40 | -0.23424398 ^ -81
41 | -178.234786 ^ -79
42 | -1274.346 ^ -8
43 | -0.2959371298 ^ 27
44 | 
45 | 


--------------------------------------------------------------------------------
/toys/other/reset.c:
--------------------------------------------------------------------------------
 1 | /* reset.c - reset the terminal.
 2 |  *
 3 |  * Copyright 2015 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * No standard.
 6 |  *
 7 |  * In 1979 3BSD's tset had a sleep(1) to let mechanical printer-and-ink
 8 |  * terminals "settle down". We're not doing that.
 9 | 
10 | USE_RESET(NEWTOY(reset, 0, TOYFLAG_USR|TOYFLAG_BIN))
11 | 
12 | config RESET
13 |   bool "reset"
14 |   default y
15 |   help
16 |     usage: reset
17 | 
18 |     Reset the terminal.
19 | */
20 | #include "toys.h"
21 | 
22 | void reset_main(void)
23 | {
24 |   int fd = tty_fd();
25 | 
26 |   // man 4 console_codes: reset terminal is ESC (no left bracket) c
27 |   // DEC private mode set enable wraparound sequence.
28 |   if (fd<0) fd = 1;
29 |   xwrite(fd, "\ec\e[?7h", 2);
30 |   set_terminal(fd, 0, 0, 0);
31 | }
32 | 


--------------------------------------------------------------------------------
/toys/other/partprobe.c:
--------------------------------------------------------------------------------
 1 | /* partprobe.c - Tell the kernel about partition table changes
 2 |  *
 3 |  * Copyright 2014 Bertold Van den Bergh <vandenbergh@bertold.org>
 4 |  *
 5 |  * see http://man7.org/linux/man-pages/man8/partprobe.8.html
 6 | 
 7 | USE_PARTPROBE(NEWTOY(partprobe, "<1", TOYFLAG_SBIN))
 8 | 
 9 | config PARTPROBE
10 |   bool "partprobe"
11 |   default y
12 |   help
13 |     usage: partprobe DEVICE...
14 | 
15 |     Tell the kernel about partition table changes
16 | 
17 |     Ask the kernel to re-read the partition table on the specified devices.
18 | */
19 | 
20 | #include "toys.h"
21 | 
22 | static void do_partprobe(int fd, char *name)
23 | {
24 |   if (ioctl(fd, BLKRRPART, 0)) perror_msg("ioctl failed");
25 | }
26 | 
27 | void partprobe_main(void)
28 | {
29 |   loopfiles(toys.optargs, do_partprobe);
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/files/bc/log_results.txt:
--------------------------------------------------------------------------------
 1 | -99999999999999999999.00000000000000000000
 2 | -.69314718055994530941
 3 | 0
 4 | .40546510810816438197
 5 | .55388511322643765995
 6 | .69314718055994530941
 7 | 1.17387435650190306676
 8 | 1.66467524885255369652
 9 | 2.58313453863349348434
10 | 4.60517018598809136803
11 | 5.64629091238730017971
12 | -99999999999999999999.00000000000000000000
13 | -99999999999999999999.00000000000000000000
14 | -99999999999999999999.00000000000000000000
15 | -99999999999999999999.00000000000000000000
16 | -99999999999999999999.00000000000000000000
17 | -99999999999999999999.00000000000000000000
18 | -99999999999999999999.00000000000000000000
19 | -99999999999999999999.00000000000000000000
20 | -99999999999999999999.00000000000000000000
21 | -99999999999999999999.00000000000000000000
22 | 16.16026492940839137014
23 | 


--------------------------------------------------------------------------------
/toys/other/pwdx.c:
--------------------------------------------------------------------------------
 1 | /* pwdx.c - report current directory of a process.
 2 |  *
 3 |  * Copyright 2013 Lukasz Skalski <l.skalski@partner.samsung.com>
 4 | 
 5 | USE_PWDX(NEWTOY(pwdx, "<1a", TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config PWDX
 8 |   bool "pwdx"
 9 |   default y
10 |   help
11 |     usage: pwdx PID...
12 | 
13 |     Print working directory of processes listed on command line.
14 | */
15 | 
16 | #include "toys.h"
17 | 
18 | void pwdx_main(void)
19 | {
20 |   char **optargs;
21 | 
22 |   for (optargs = toys.optargs; *optargs; optargs++) {
23 |     char *path = toybuf;
24 | 
25 |     sprintf(toybuf, "/proc/%d/cwd", atoi(*optargs));
26 |     if (!readlink0(path, toybuf, sizeof(toybuf))) {
27 |       path = strerror(errno);
28 |       toys.exitval = 1;
29 |     }
30 | 
31 |     xprintf("%s: %s\n", *optargs, path);
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/files/bc/exponent_results.txt:
--------------------------------------------------------------------------------
 1 | 1.00000000000000000000
 2 | 1.64872127070012814684
 3 | 2.71828182845904523536
 4 | 4.48168907033806482260
 5 | 5.69734342267199101193
 6 | 7.38905609893065022723
 7 | 25.39367176822616278859
 8 | 197.14845034328553587817
 9 | 561613.96621445383501864766
10 | 26881171418161354484126255515800135873611118.77374192241519160861
11 | 10212124131159922810249757193864245307850725332411569566443792548720\
12 | 75182918653384240389953781407569563117008113027037939783.70141667971\
13 | 570827872
14 | .60653065971263342360
15 | .36787944117144232159
16 | .22313016014842982893
17 | .17552040061699687169
18 | .13533528323661269189
19 | .03937988996342191888
20 | .00507231985977442865
21 | .00000178058250000525
22 | 0
23 | 0
24 | 98928445824097165243611240348236907682258759298273030827411201.25833\
25 | 645622510213538
26 | 


--------------------------------------------------------------------------------
/toys/other/tac.c:
--------------------------------------------------------------------------------
 1 | /* tac.c - output lines in reverse order
 2 |  *
 3 |  * Copyright 2012 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_TAC(NEWTOY(tac, NULL, TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config TAC
 8 |   bool "tac"
 9 |   default y
10 |   help
11 |     usage: tac [FILE...]
12 | 
13 |     Output lines in reverse order.
14 | */
15 | 
16 | #define FOR_tac
17 | #include "toys.h"
18 | 
19 | GLOBALS(
20 |   struct double_list *dl;
21 | )
22 | 
23 | static void do_tac(char **pline, long len)
24 | {
25 |   if (pline) {
26 |     dlist_add(&TT.dl, *pline);
27 |     *pline = 0;
28 |   } else while (TT.dl) {
29 |     struct double_list *dl = dlist_lpop(&TT.dl);
30 | 
31 |     xprintf("%s", dl->data);
32 |     free(dl->data);
33 |     free(dl);
34 |   }
35 | }
36 | 
37 | void tac_main(void)
38 | {
39 |   loopfiles_lines(toys.optargs, do_tac);
40 | }
41 | 


--------------------------------------------------------------------------------
/toys/other/fsync.c:
--------------------------------------------------------------------------------
 1 | /* fsync.c - Synchronize a file's in-core state with storage device.
 2 |  *
 3 |  * Copyright 2015 Ranjan Kumar <ranjankumar.bth@gmail.comi>
 4 |  *
 5 |  * No Standard.
 6 | 
 7 | USE_FSYNC(NEWTOY(fsync, "<1d", TOYFLAG_BIN))
 8 | 
 9 | config FSYNC
10 |   bool "fsync"
11 |   default y
12 |   help
13 |     usage: fsync [-d] [FILE...]
14 | 
15 |     Flush disk cache for FILE(s), writing cached data to storage device.
16 | 
17 |     -d	Skip directory info (sync file contents only).
18 | */
19 | 
20 | #define FOR_fsync
21 | #include "toys.h"
22 | 
23 | static void do_fsync(int fd, char *name)
24 | {
25 |   if (FLAG(d) ? fdatasync(fd) : fsync(fd)) perror_msg("can't sync '%s'", name);
26 | }
27 | 
28 | void fsync_main(void)
29 | {
30 |   loopfiles_rw(toys.optargs, O_RDONLY|O_NOATIME|O_NOCTTY|O_CLOEXEC|WARN_ONLY,
31 |       0, do_fsync);
32 | }
33 | 


--------------------------------------------------------------------------------
/scripts/prereq/generated/help.h:
--------------------------------------------------------------------------------
 1 | #define HELP_toybox ""
 2 | #define HELP_ln ""
 3 | #define HELP_as ""
 4 | #define HELP_basename ""
 5 | #define HELP_cat ""
 6 | #define HELP_cc ""
 7 | #define HELP_chmod ""
 8 | #define HELP_cmp ""
 9 | #define HELP_dirname ""
10 | #define HELP_echo ""
11 | #define HELP_egrep ""
12 | #define HELP_fold ""
13 | #define HELP_git ""
14 | #define HELP_grep ""
15 | #define HELP_gzip ""
16 | #define HELP_head ""
17 | #define HELP_ld ""
18 | #define HELP_ls ""
19 | #define HELP_make ""
20 | #define HELP_mkdir ""
21 | #define HELP_od ""
22 | #define HELP_readlink ""
23 | #define HELP_rm ""
24 | #define HELP_sed ""
25 | #define HELP_sort ""
26 | #define HELP_strip ""
27 | #define HELP_tail ""
28 | #define HELP_tee ""
29 | #define HELP_tr ""
30 | #define HELP_uname ""
31 | #define HELP_wc ""
32 | #define HELP_which ""
33 | #define HELP_xargs ""
34 | 


--------------------------------------------------------------------------------
/toys/other/fallocate.c:
--------------------------------------------------------------------------------
 1 | /* fallocate.c - Preallocate space to a file
 2 |  *
 3 |  * Copyright 2013 Felix Janda <felix.janda@posteo.de>
 4 |  *
 5 |  * No standard
 6 | 
 7 | USE_FALLOCATE(NEWTOY(fallocate, ">1l#|o#", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config FALLOCATE
10 |   bool "fallocate"
11 |   default y
12 |   help
13 |     usage: fallocate [-o OFFSET] -l SIZE FILE
14 | 
15 |     Tell the filesystem to allocate space for a range in a file.
16 | 
17 |     -l	Number of bytes in range
18 |     -o	Start offset of range (default 0)
19 | */
20 | 
21 | #define FOR_fallocate
22 | #include "toys.h"
23 | 
24 | GLOBALS(
25 |   long o, l;
26 | )
27 | 
28 | void fallocate_main(void)
29 | {
30 |   int fd = xcreate(*toys.optargs, O_RDWR | O_CREAT, 0644);
31 |   if ((errno = posix_fallocate(fd, TT.o, TT.l))) perror_exit("fallocate");
32 |   if (CFG_TOYBOX_FREE) close(fd);
33 | }
34 | 


--------------------------------------------------------------------------------
/toys/other/readahead.c:
--------------------------------------------------------------------------------
 1 | /* readahead.c - preload files into disk cache.
 2 |  *
 3 |  * Copyright 2013 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * No standard.
 6 | 
 7 | USE_READAHEAD(NEWTOY(readahead, NULL, TOYFLAG_BIN))
 8 | 
 9 | config READAHEAD
10 |   bool "readahead"
11 |   default y
12 |   help
13 |     usage: readahead FILE...
14 | 
15 |     Preload files into disk cache.
16 | */
17 | 
18 | #define _LARGEFILE64_SOURCE  // musl's _ALL_SOURCE lies, no off64_t
19 | #include "toys.h"
20 | 
21 | // glibc won't provide this prototype unless we claim Linux belongs to the FSF
22 | ssize_t readahead(int fd, off64_t offset, size_t count);
23 | 
24 | static void do_readahead(int fd, char *name)
25 | {
26 |   if (readahead(fd, 0, INT_MAX)) perror_msg("readahead: %s", name);
27 | }
28 | 
29 | void readahead_main(void)
30 | {
31 |   loopfiles(toys.optargs, do_readahead);
32 | }
33 | 


--------------------------------------------------------------------------------
/toys/other/memeater.c:
--------------------------------------------------------------------------------
 1 | /* memeater.c - consume the specified amount of memory
 2 |  *
 3 |  * Copyright 2024 The Android Open Source Project
 4 | 
 5 | USE_MEMEATER(NEWTOY(memeater, "<1>1M", TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config MEMEATER
 8 |   bool "memeater"
 9 |   default y
10 |   help
11 |     usage: memeater [-M] BYTES
12 | 
13 |     Consume the specified amount of memory and wait to be killed.
14 | 
15 |     -M	Don't mlock() the memory (let it swap out).
16 | */
17 | 
18 | #define FOR_memeater
19 | #include "toys.h"
20 | 
21 | void memeater_main(void)
22 | {
23 |   unsigned long size = atolx_range(*toys.optargs, 0, LONG_MAX), i,
24 |     *p = xmalloc(size);
25 | 
26 |   // Lock and dirty the physical pages.
27 |   if (!FLAG(M) && mlock(p, size)) perror_exit("mlock");
28 |   for (i = 0; i<size; i += 4096) p[i/sizeof(long)] = i;
29 | 
30 |   while (1) pause();
31 | }
32 | 


--------------------------------------------------------------------------------
/tests/files/bc/modulus_results.txt:
--------------------------------------------------------------------------------
 1 | 0
 2 | 0
 3 | 0
 4 | 0
 5 | 0
 6 | 0
 7 | 0
 8 | .00000000000000002026
 9 | 2747189239559.46904933397471305894
10 | 0
11 | 0
12 | -.00000000000011057855
13 | -.00076922992566770712
14 | -.00000000000050364144
15 | 0
16 | 0
17 | 0
18 | .00000000000000000002
19 | 0
20 | 0
21 | 0
22 | .00000000070585524350
23 | .00000000000000002898
24 | 0
25 | 0
26 | 0
27 | -.00000000000000000002
28 | -.00000000000000000005
29 | 0
30 | -.00000000000000000002
31 | -.00000000000000011722
32 | -.00000002640923745817
33 | 0
34 | 0
35 | 0
36 | 3
37 | 1
38 | 3
39 | 0
40 | 8758
41 | 3496723859067234
42 | 0
43 | 0
44 | -8236960
45 | -1274852934765
46 | -140529951
47 | 0
48 | 0
49 | 0
50 | 2
51 | 1
52 | 0
53 | 4
54 | 89237423
55 | 6692
56 | 0
57 | 0
58 | 0
59 | -2
60 | -6
61 | 0
62 | -1
63 | -14016
64 | -127849612
65 | -626616737
66 | -899510228.00000
67 | -153.1331732059
68 | .4
69 | 


--------------------------------------------------------------------------------
/toys/android/load_policy.c:
--------------------------------------------------------------------------------
 1 | /* load_policy.c - Load an SELinux policy file
 2 |  *
 3 |  * Copyright 2015 The Android Open Source Project
 4 | 
 5 | USE_LOAD_POLICY(NEWTOY(load_policy, "<1>1", TOYFLAG_USR|TOYFLAG_SBIN))
 6 | 
 7 | config LOAD_POLICY
 8 |   bool "load_policy"
 9 |   depends on TOYBOX_SELINUX
10 |   default y
11 |   help
12 |     usage: load_policy FILE
13 | 
14 |     Load the specified SELinux policy file.
15 | */
16 | 
17 | #define FOR_load_policy
18 | #include "toys.h"
19 | 
20 | void load_policy_main(void)
21 | {
22 |   int fd = xopenro(*toys.optargs);
23 |   off_t policy_len = fdlength(fd);
24 |   char *policy_data = xmmap(0, policy_len, PROT_READ, MAP_PRIVATE, fd, 0);
25 | 
26 |   close(fd);
27 |   if (security_load_policy(policy_data, policy_len) < 0)
28 |     perror_exit("security_load_policy %s", *toys.optargs);
29 | 
30 |   munmap(policy_data, policy_len);
31 | }
32 | 


--------------------------------------------------------------------------------
/toys/other/rev.c:
--------------------------------------------------------------------------------
 1 | /* rev.c - reverse lines of a set of given input files
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | USE_REV(NEWTOY(rev, NULL, TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config REV
 8 |   bool "rev"
 9 |   default y
10 |   help
11 |     usage: rev [FILE...]
12 | 
13 |     Output each line reversed, when no files are given stdin is used.
14 | */
15 | 
16 | #include "toys.h"
17 | 
18 | static void rev_line(char **pline, long len)
19 | {
20 |   char *line;
21 |   long i;
22 | 
23 |   if (!pline) return;
24 |   line = *pline;
25 |   if (len && line[len-1]=='\n') line[--len] = 0;
26 | 
27 |   if (len--) for (i = 0; i <= len/2; i++) {
28 |     char tmp = line[i];
29 | 
30 |     line[i] = line[len-i];
31 |     line[len-i] = tmp;
32 |   }
33 |   xputs(line);
34 | }
35 | 
36 | void rev_main(void)
37 | {
38 |   loopfiles_lines(toys.optargs, rev_line);
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/bc.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testcmd "name "args" "result" "infile" "stdin"
 6 | 
 7 | BDIR="$FILES/bc"
 8 | 
 9 | run_bc_test() {
10 | 	tst="$1"
11 | 	results=$(cat "$BDIR/${tst}_results.txt")
12 | 	testcmd "$tst" "-l $BDIR/$tst.txt" "$results\n" "$BDIR/$tst.txt" ""
13 | }
14 | 
15 | run_bc_test decimal
16 | run_bc_test add
17 | run_bc_test subtract
18 | run_bc_test multiply
19 | run_bc_test divide
20 | run_bc_test modulus
21 | run_bc_test power
22 | run_bc_test sqrt
23 | run_bc_test vars
24 | run_bc_test boolean
25 | run_bc_test parse
26 | run_bc_test print
27 | run_bc_test exponent
28 | run_bc_test log
29 | run_bc_test pi
30 | run_bc_test arctan
31 | run_bc_test sine
32 | run_bc_test cosine
33 | run_bc_test bessel
34 | run_bc_test arrays
35 | run_bc_test misc
36 | run_bc_test misc1
37 | run_bc_test misc2
38 | 
39 | testcmd "stdin" "" "2\n" "" "1+1\n"
40 | 


--------------------------------------------------------------------------------
/toys/posix/sleep.c:
--------------------------------------------------------------------------------
 1 | /* sleep.c - Wait for a number of seconds.
 2 |  *
 3 |  * Copyright 2007 Rob Landley <rob@landley.net>
 4 |  * Copyright 2012 Georgi Chorbadzhiyski <georgi@unixsol.org>
 5 |  *
 6 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/sleep.html
 7 | 
 8 | USE_SLEEP(NEWTOY(sleep, "<1", TOYFLAG_BIN))
 9 | 
10 | config SLEEP
11 |   bool "sleep"
12 |   default y
13 |   help
14 |     usage: sleep DURATION...
15 | 
16 |     Wait before exiting.
17 | 
18 |     DURATION can be a decimal fraction. An optional suffix can be "m"
19 |     (minutes), "h" (hours), "d" (days), or "s" (seconds, the default).
20 | */
21 | 
22 | #include "toys.h"
23 | 
24 | void sleep_main(void)
25 | {
26 |   struct timespec ts;
27 |   char **args;
28 | 
29 |   for (args = toys.optargs; !toys.exitval && *args; args++) {
30 |     xparsetimespec(*args, &ts);
31 |     toys.exitval = !!nanosleep(&ts, NULL);
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/install.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # TODO: fill this out.
 4 | # TODO: "make install" means something else, so no test_install, only callable
 5 | # from "make tests"...
 6 | 
 7 | [ -f testing.sh ] && . testing.sh
 8 | 
 9 | #testing "name" "command" "result" "infile" "stdin"
10 | 
11 | dd if=/dev/urandom of=random bs=64 count=1 2> /dev/null
12 | testing "install -D exists" \
13 |   "mkdir -p a; touch a/b; install -D random a/b && cmp random a/b && echo yes" \
14 |   "yes\n" "" ""
15 | rm -rf a random
16 | testing "install -D -t creates directory" \
17 |   "touch a; install -Dt b a && echo yes" \
18 |   "yes\n" "" ""
19 | rm -rf a b
20 | 
21 | testing "install -d" "umask 0 && install -d potato && stat -c%a potato" \
22 |   "755\n" "" ""
23 | rmdir potato
24 | testcmd "-dm" "-dm 02750 potato && stat -c%a potato" "2750\n" "" ""
25 | rmdir potato
26 | testcmd '' '-dm +x potato && stat -c%a potato' '111\n' '' ''
27 | 


--------------------------------------------------------------------------------
/tests/iconv.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | # Example characters from https://en.wikipedia.org/wiki/UTF-16:
 6 | # $:U+0024  €:U+20ac  𐐷:U+10437[==U+d801,U+dc37]
 7 | # We can't simply use echo because bash 3.2 on the Mac mangles it, but toysh
 8 | # should let us go back to just this when it's available...
 9 | #   echo -n "$€𐐷" > chars
10 | echo -ne "\x24\xe2\x82\xac\xf0\x90\x90\xb7" > chars
11 | 
12 | #testing "name" "command" "result" "infile" "stdin"
13 | utf8locale
14 | testing "" "iconv chars | xxd -p" "24e282acf09090b7\n" "" ""
15 | testing "-t UTF-16BE" "iconv -t UTF-16BE chars | xxd -p" "002420acd801dc37\n" "" ""
16 | testing "-t UTF-16LE" "iconv -t UTF-16LE chars | xxd -p" "2400ac2001d837dc\n" "" ""
17 | testing "-t UTF-32BE" "iconv -t UTF-32BE chars | xxd -p" "00000024000020ac00010437\n" "" ""
18 | testing "-t UTF-32LE" "iconv -t UTF-32LE chars | xxd -p" "24000000ac20000037040100\n" "" ""
19 | 


--------------------------------------------------------------------------------
/toys/other/swapon.c:
--------------------------------------------------------------------------------
 1 | /* swapon.c - Enable region for swapping
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | USE_SWAPON(NEWTOY(swapon, "<1>1p#<0>32767d", TOYFLAG_SBIN|TOYFLAG_NEEDROOT))
 6 | 
 7 | config SWAPON
 8 |   bool "swapon"
 9 |   default y
10 |   help
11 |     usage: swapon [-d] [-p priority] filename
12 | 
13 |     Enable swapping on a given device/file.
14 | 
15 |     -d	Discard freed SSD pages
16 |     -p	Priority (highest priority areas allocated first)
17 | */
18 | 
19 | #define FOR_swapon
20 | #include "toys.h"
21 | 
22 | GLOBALS(
23 |   long p;
24 | )
25 | 
26 | void swapon_main(void)
27 | {
28 |   // SWAP_FLAG_DISCARD|SWAP_FLAG_DISCARD_ONCE|SWAP_FLAG_DISCARD_PAGES
29 |   int flags = FLAG(d)*0x70000;
30 | 
31 |   if (FLAG(p)) flags |= SWAP_FLAG_PREFER | (TT.p << SWAP_FLAG_PRIO_SHIFT);
32 |   if (swapon(*toys.optargs, flags))
33 |     perror_exit("Couldn't swapon '%s'", *toys.optargs);
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/link.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Copyright 2014 Divya Kothari <divya.s.kothari@gmail.com>
 4 | # Copyright 2014 Naha Maggu <maggu.neha@gmail.com>
 5 | 
 6 | [ -f testing.sh ] && . testing.sh
 7 | 
 8 | #testing "name" "command" "result" "infile" "stdin"
 9 | 
10 | echo "" >foo
11 | testing "fails on non-existent file" "link foo/foo baz 2>/dev/null || echo GOOD" "GOOD\n" "" ""
12 | rm -f foo bar
13 | 
14 | echo file1 > file
15 | testing "create_hardlink" "link file hlink && [ file -ef hlink ] &&
16 |           echo 'yes'; rm  -rf hlink" "yes\n" "" ""
17 | 
18 | echo hlink1 > hlink
19 | set +e
20 | testing "preserves_hardlinks" "link file hlink 2>/dev/null || echo 'yes'; rm -rf hlink" \
21 |           "yes\n" "" ""
22 | 
23 | echo file1 > file
24 | testing "create_hardlink_and_remove_sourcefile" "link file hlink &&
25 |           [ file -ef hlink ] && rm -rf file && [ -f hlink ] && echo 'yes'; rm -f file hlink" \
26 |           "yes\n" "" ""
27 | 


--------------------------------------------------------------------------------
/toys/other/flock.c:
--------------------------------------------------------------------------------
 1 | /* flock.c - manage advisory file locks
 2 |  *
 3 |  * Copyright 2015 The Android Open Source Project
 4 | 
 5 | USE_FLOCK(NEWTOY(flock, "<1>1nsux[-sux]", TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config FLOCK
 8 |   bool "flock"
 9 |   default y
10 |   help
11 |     usage: flock [-sxun] fd
12 | 
13 |     Manage advisory file locks.
14 | 
15 |     -s	Shared lock
16 |     -x	Exclusive lock (default)
17 |     -u	Unlock
18 |     -n	Non-blocking: fail rather than wait for the lock
19 | */
20 | 
21 | #define FOR_flock
22 | #include "toys.h"
23 | 
24 | #include <sys/file.h>
25 | 
26 | void flock_main(void)
27 | {
28 |   int fd = xstrtol(*toys.optargs, NULL, 10), op;
29 | 
30 |   if (FLAG(u)) op = LOCK_UN;
31 |   else op = FLAG(s) ? LOCK_SH : LOCK_EX;
32 | 
33 |   if (FLAG(n)) op |= LOCK_NB;
34 | 
35 |   if (flock(fd, op)) {
36 |     if ((op & LOCK_NB) && errno == EAGAIN) toys.exitval = 1;
37 |     else perror_exit("flock");
38 |   }
39 | }
40 | 


--------------------------------------------------------------------------------
/toys/other/pivot_root.c:
--------------------------------------------------------------------------------
 1 | /* pivot_root.c - edit system mount tree
 2 |  *
 3 |  * Copyright 2012 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_PIVOT_ROOT(NEWTOY(pivot_root, "<2>2", TOYFLAG_SBIN))
 6 | 
 7 | config PIVOT_ROOT
 8 |   bool "pivot_root"
 9 |   default y
10 |   help
11 |     usage: pivot_root OLD NEW
12 | 
13 |     Swap OLD and NEW filesystems (as if by simultaneous mount --move), and
14 |     move all processes with chdir or chroot under OLD into NEW (including
15 |     kernel threads) so OLD may be unmounted.
16 | 
17 |     The directory NEW must exist under OLD. This doesn't work on initramfs,
18 |     which can't be moved (about the same way PID 1 can't be killed; see
19 |     switch_root instead).
20 | */
21 | 
22 | #define FOR_pivot_root
23 | #include "toys.h"
24 | 
25 | void pivot_root_main(void)
26 | {
27 |   if (syscall(__NR_pivot_root, toys.optargs[0], toys.optargs[1]))
28 |     perror_exit("'%s' -> '%s'", toys.optargs[0], toys.optargs[1]);
29 | }
30 | 


--------------------------------------------------------------------------------
/tests/uuencode.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "not enough args [fail]" "uuencode 2>/dev/null" "" "" ""
 8 | 
 9 | testing "uu empty file" "uuencode test" \
10 | 	"begin 744 test\nend\n" "" "" 
11 | testing "uu 1-char" "uuencode test" \
12 | 	"begin 744 test\n!80\`\`\nend\n" "" "a" 
13 | testing "uu 2-char" "uuencode test" \
14 | 	"begin 744 test\n\"86(\`\nend\n" "" "ab" 
15 | testing "uu 3-char" "uuencode test" \
16 | 	"begin 744 test\n#86)C\nend\n" "" "abc" 
17 | 
18 | testing "b64 empty file" "uuencode -m test" \
19 | 	"begin-base64 744 test\n====\n" "" "" 
20 | testing "b64 1-char" "uuencode -m test" \
21 | 	"begin-base64 744 test\nYQ==\n====\n" "" "a" 
22 | testing "b64 2-char" "uuencode -m test" \
23 | 	"begin-base64 744 test\nYWI=\n====\n" "" "ab" 
24 | testing "b64 3-char" "uuencode -m test" \
25 | 	"begin-base64 744 test\nYWJj\n====\n" "" "abc" 
26 | 
27 | 


--------------------------------------------------------------------------------
/tests/files/bc/divide_results.txt:
--------------------------------------------------------------------------------
 1 | 0
 2 | 0
 3 | 0
 4 | 1.00000000000000000000
 5 | .00000000000077671755
 6 | 4.17419336592637110778
 7 | .00000000000420899796
 8 | .00041271738677857404
 9 | 10591131829.40901859967857131767
10 | 9483402361494453751.52388015648196297248
11 | 15063068.13735316451497043884
12 | -90.11223545260531110575
13 | -1057067521778623447.45138528213564485251
14 | -11.94161814246320631346
15 | -.00000000005126306228
16 | -1.14705437777218917343
17 | -.00000000000194126663
18 | -485262.88923145638029569727
19 | -100024372711.74763635544535424582
20 | -.00682569681609989277
21 | 25638.20711150436682153521
22 | 2700714504347599627864.24626421085374010264
23 | 10906.42973524078145692731
24 | .00000000000000017054
25 | .21260557443109085166
26 | 3.89799997647407910677
27 | .00000000000006801538
28 | 3988.13076601933678578945
29 | 100864416620775.31076855630746548983
30 | .00000000052530099381
31 | 42612515855353136519261264261472677699404182.78776061098893912189
32 | 


--------------------------------------------------------------------------------
/tests/files/bc/misc1.txt:
--------------------------------------------------------------------------------
 1 | define x(x) {
 2 | 	return(x)
 3 | }
 4 | define y() {
 5 | 	return;
 6 | }
 7 | define z() {
 8 | 	return ();
 9 | }
10 | scale = 0
11 | x=2
12 | x[0]=3
13 | x
14 | x[0]
15 | scale
16 | ibase
17 | obase
18 | x ( 7 )
19 | x + x( 8 )
20 | x - x[0]
21 | 321 * x
22 | 2 ^ x[0]
23 | x++
24 | --x
25 | x += 9
26 | x
27 | length(2381)
28 | sqrt(9)
29 | scale(238.1)
30 | x=2
31 | x[0]=3
32 | (x)
33 | (x[0])
34 | (scale)
35 | (ibase)
36 | (obase)
37 | (x ( 7 ))
38 | (x + x( 8 ))
39 | (x - x[0])
40 | (321 * x)
41 | (2 ^ x[0])
42 | (x++)
43 | (--x)
44 | (x += 9)
45 | (length(2381))
46 | (sqrt(9))
47 | (scale(238.1))
48 | (scale = 0)
49 | (x = 10)
50 | (x += 100)
51 | (x -= 10)
52 | (x *= 10)
53 | (x /= 100)
54 | (x ^= 10)
55 | (x = sqrt(x))
56 | (x[1 - 1])
57 | x[(1 - 1)]
58 | 2 + \
59 | 3
60 | ++ibase
61 | --ibase
62 | ++obase
63 | --obase
64 | ++last
65 | --last
66 | last
67 | last = 100
68 | last
69 | . = 150
70 | .
71 | ++scale
72 | --scale
73 | y()
74 | z()
75 | 2 + /*
76 | */3
77 | 


--------------------------------------------------------------------------------
/configure:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # set environment variables used by scripts/make.sh
 4 | 
 5 | # People run ./configure out of habit, so do "defconfig" for them.
 6 | 
 7 | if [ "$(basename "$0")" == configure ]
 8 | then
 9 |   echo "Assuming you want 'make defconfig', but you should probably check the README."
10 |   make defconfig
11 |   exit $?
12 | fi
13 | 
14 | # Warn about stuff, disable stupid warnings, be 8-bit clean for utf8.
15 | [ "${CFLAGS/-funsigned-char//}" == "$CFLAGS" ] &&
16 |   CFLAGS+=" -Wall -Wundef -Werror=implicit-function-declaration -Wno-char-subscripts -Wno-pointer-sign -funsigned-char"
17 | 
18 | # Set default values if variable not already set
19 | : ${CC:=cc} ${HOSTCC:=cc} ${GENDIR:=generated} ${KCONFIG_CONFIG:=.config}
20 | : ${UNSTRIPPED:=$GENDIR/unstripped} ${OUTNAME:=toybox${TARGET:+-$TARGET}}
21 | : ${OPTIMIZE:=-Os -ffunction-sections -fdata-sections -fno-asynchronous-unwind-tables -fno-strict-aliasing}
22 | 
23 | # We accept LDFLAGS, but by default don't have anything in it
24 | 


--------------------------------------------------------------------------------
/scripts/git-static-index.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Create very basic index.html and commit links for a static git archive
 4 | 
 5 | mkdir -p commit
 6 | git log --pretty=%H | while read i
 7 | do
 8 |   [ -e commit/$i ] && break
 9 |   git format-patch -1 --stdout $i > commit/$i
10 |   ln -sf $i commit/${i::12}
11 | done
12 | 
13 | echo '<html><body><font face=monospace><table border=1 cellpadding=2>'
14 | echo '<tr valign=top><td>commit</td><td>author</td><td>date</td><td>description</td></tr>'
15 | git log --pretty='%H%n%an<%ae>%n%ad%n%s' --date=format:'%r<br />%d-%m-%Y' | while read HASH
16 | do
17 |   HASH="${HASH::12}"
18 |   read AUTHOR
19 |   AUTHOR1="${AUTHOR/<*/}"
20 |   AUTHOR1="${AUTHOR1::17}"
21 |   AUTHOR2="&lt;${AUTHOR/*</}"
22 |   AUTHOR2="${AUTHOR2::20}"
23 |   read DATE
24 |   DATE="${DATE/ /&nbsp;}"
25 |   read DESC
26 |   echo "<tr valign=top><td><a href=commit/$HASH>$HASH</a></td><td>$AUTHOR1<br />$AUTHOR2</td><td>$DATE</td><td>$DESC</td></tr>"
27 | done
28 | echo "</table></body></html>"
29 | 


--------------------------------------------------------------------------------
/toys/android/setenforce.c:
--------------------------------------------------------------------------------
 1 | /* setenforce.c - Set the current SELinux mode
 2 |  *
 3 |  * Copyright 2014 The Android Open Source Project
 4 | 
 5 | USE_SETENFORCE(NEWTOY(setenforce, "<1>1", TOYFLAG_USR|TOYFLAG_SBIN))
 6 | 
 7 | config SETENFORCE
 8 |   bool "setenforce"
 9 |   default y
10 |   depends on TOYBOX_SELINUX
11 |   help
12 |     usage: setenforce [enforcing|permissive|1|0]
13 | 
14 |     Sets whether SELinux is enforcing (1) or permissive (0).
15 | */
16 | 
17 | #define FOR_setenforce
18 | #include "toys.h"
19 | 
20 | void setenforce_main(void)
21 | {
22 |   char *new = *toys.optargs;
23 |   int state, ret;
24 | 
25 |   if (!is_selinux_enabled()) error_exit("SELinux is disabled");
26 |   else if (!strcmp(new, "1") || !strcasecmp(new, "enforcing")) state = 1;
27 |   else if (!strcmp(new, "0") || !strcasecmp(new, "permissive")) state = 0;
28 |   else error_exit("Invalid state: %s", new);
29 | 
30 |   ret = security_setenforce(state);
31 |   if (ret == -1) perror_msg("Couldn't set enforcing status to '%s'", new);
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/files/zip/d1/d2/x.txt:
--------------------------------------------------------------------------------
1 | xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx


--------------------------------------------------------------------------------
/tests/pidof.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | #
 8 | # pidof (unlike killall) doesn't match argv[1] unless you supply -x.
 9 | #
10 | 
11 | mkfifo fifo
12 | echo -e "#!$(which sh)\nread i < fifo" > pidof-$$.test
13 | chmod a+x pidof-$$.test
14 | cp pidof-$$.test toybox.pidof-$$.test.script
15 | (./pidof-$$.test & echo $! > pid.txt)
16 | pid=$(cat pid.txt)
17 | testcmd "short argv[1]" "pidof-$$.test" "" "" ""
18 | testcmd "short argv[1] -x" "-x pidof-$$.test" "$pid\n" "" ""
19 | kill $pid
20 | 
21 | (./toybox.pidof-$$.test.script & echo $! > pid.txt)
22 | pid=$(cat pid.txt)
23 | testcmd "long argv[1]" "toybox.pidof-$$.test.script" "" "" ""
24 | testcmd "long argv[1] -x" "-x toybox.pidof-$$.test.script" "$pid\n" "" ""
25 | kill $pid
26 | 
27 | rm -f toybox.pidof-$$.test.script pidof-$$.test pid.txt fifo
28 | 
29 | # pidof (unlike killall) will match itself.
30 | testcmd "pidof pidof" "pidof > /dev/null && echo found" "found\n" "" ""
31 | 


--------------------------------------------------------------------------------
/toys/android/sendevent.c:
--------------------------------------------------------------------------------
 1 | /* sendevent.c - Send Linux input events.
 2 |  *
 3 |  * Copyright 2016 The Android Open Source Project
 4 | 
 5 | USE_SENDEVENT(NEWTOY(sendevent, "<4>4", TOYFLAG_USR|TOYFLAG_SBIN))
 6 | 
 7 | config SENDEVENT
 8 |   bool "sendevent"
 9 |   default y
10 |   depends on TOYBOX_ON_ANDROID
11 |   help
12 |     usage: sendevent DEVICE TYPE CODE VALUE
13 | 
14 |     Sends a Linux input event.
15 | */
16 | 
17 | #define FOR_sendevent
18 | #include "toys.h"
19 | 
20 | #include <linux/input.h>
21 | 
22 | void sendevent_main(void)
23 | {
24 |   int fd = xopen(*toys.optargs, O_RDWR);
25 |   int version;
26 |   struct input_event ev;
27 | 
28 |   if (ioctl(fd, EVIOCGVERSION, &version))
29 |     perror_exit("EVIOCGVERSION failed for %s", *toys.optargs);
30 | 
31 |   memset(&ev, 0, sizeof(ev));
32 |   // TODO: error checking and support for named constants.
33 |   ev.type = atoi(toys.optargs[1]);
34 |   ev.code = atoi(toys.optargs[2]);
35 |   ev.value = atoi(toys.optargs[3]);
36 |   xwrite(fd, &ev, sizeof(ev));
37 | }
38 | 


--------------------------------------------------------------------------------
/toys/example/README:
--------------------------------------------------------------------------------
 1 | Example commands
 2 | 
 3 | You probably don't want to deploy any of this.
 4 | 
 5 | The hello.c and skeleton.c commands provide templates for new commands. When
 6 | writing a new command, copying hello.c or skeleton.c to the new name may provide
 7 | a good starting point. (The minimal staring point is toys/posix/false.c)
 8 | 
 9 |   - hello.c is clean and simple, and an easy way to check the behavior of
10 |     toybox library functions running in command context.
11 | 
12 |   - skeleton.c demonstrates the option parsing infrastructure and having
13 |     multiple commands per file.
14 | 
15 | Some of the commands in here are test infrastructure:
16 | 
17 |   - logpath.c is optionally used by mkroot.sh and scripts/record-commands
18 | 
19 |   - demo_* demonstrates infrastructure, allowing tests/demo_*.test to
20 |     regression test library functions directly.
21 | 
22 | hostid.c is an obsolete command still in posix and present on some recent
23 | Linux systems, but not really useful on modern systems.
24 | 


--------------------------------------------------------------------------------
/toys/other/mcookie.c:
--------------------------------------------------------------------------------
 1 | /* mcookie - generate a 128-bit random number (used for X "magic cookies")
 2 |  *
 3 |  * Copyright 2019 AD Isaac Dunham <ibid.ag@gmail.com>
 4 |  *
 5 |  * No standard.
 6 |  *
 7 |  * -f and -m are not supported: md5sums of arbitrary files are not a good
 8 |  * source of entropy, just ask the system for 128 bits and print it.
 9 | 
10 | USE_MCOOKIE(NEWTOY(mcookie, "v(verbose)V(version)", TOYFLAG_USR|TOYFLAG_BIN))
11 | 
12 | config MCOOKIE
13 |   bool "mcookie"
14 |   default y
15 |   help
16 |     usage: mcookie [-vV]
17 | 
18 |     Generate a 128-bit strong random number.
19 | 
20 |     -v  show entropy source (verbose)
21 |     -V  show version
22 | */
23 | 
24 | #define FOR_mcookie
25 | #include "toys.h"
26 | 
27 | void mcookie_main(void)
28 | {
29 |   long long *ll = (void *)toybuf;
30 | 
31 |   if (FLAG(V)) return (void)puts("mcookie from toybox");
32 |   xgetrandom(toybuf, 16);
33 |   if (FLAG(v)) fputs("Got 16 bytes from xgetrandom()\n", stderr);
34 |   xprintf("%016llx%06llx\n", ll[0], ll[1]);
35 | }
36 | 


--------------------------------------------------------------------------------
/toys/other/printenv.c:
--------------------------------------------------------------------------------
 1 | /* printenv.c - Print environment variables.
 2 |  *
 3 |  * Copyright 2012 Georgi Chorbadzhiyski <georgi@unixsol.org>
 4 | 
 5 | USE_PRINTENV(NEWTOY(printenv, "(null)0", TOYFLAG_BIN))
 6 | 
 7 | config PRINTENV
 8 |   bool "printenv"
 9 |   default y
10 |   help
11 |     usage: printenv [-0] [env_var...]
12 | 
13 |     Print environment variables.
14 | 
15 |     -0	Use \0 as delimiter instead of \n
16 | */
17 | 
18 | #include "toys.h"
19 | 
20 | void printenv_main(void)
21 | {
22 |   char **env, **var = toys.optargs;
23 |   char delim = '\n';
24 | 
25 |   if (toys.optflags) delim = 0;
26 | 
27 |   do {
28 |     int catch = 0, len = *var ? strlen(*var) : 0;
29 | 
30 |     for (env = environ; *env; env++) {
31 |       char *out = *env;
32 |       if (*var) {
33 |         if (!strncmp(out, *var, len) && out[len] == '=') out += len +1;
34 |         else continue;
35 |       }
36 |       xprintf("%s%c", out, delim);
37 |       catch++;
38 |     }
39 |     if (*var && !catch) toys.exitval = 1;
40 |   } while (*var && *(++var));
41 | }
42 | 


--------------------------------------------------------------------------------
/toys/other/setfattr.c:
--------------------------------------------------------------------------------
 1 | /* setfattr.c - Write POSIX extended attributes.
 2 |  *
 3 |  * Copyright 2016 Android Open Source Project.
 4 |  *
 5 |  * No standard
 6 | 
 7 | USE_SETFATTR(NEWTOY(setfattr, "hn:|v:x:|[!xv]", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config SETFATTR
10 |   bool "setfattr"
11 |   default y
12 |   help
13 |     usage: setfattr [-h] [-x|-n NAME] [-v VALUE] FILE...
14 | 
15 |     Write POSIX extended attributes.
16 | 
17 |     -h	Do not dereference symlink
18 |     -n	Set given attribute
19 |     -x	Remove given attribute
20 |     -v	Set value for attribute -n (default is empty)
21 | */
22 | 
23 | #define FOR_setfattr
24 | #include "toys.h"
25 | 
26 | GLOBALS(
27 |   char *x, *v, *n;
28 | )
29 | 
30 | void setfattr_main(void)
31 | {
32 |   int h = FLAG(h), rc;
33 |   char **s;
34 | 
35 |   for (s = toys.optargs; *s; s++) {
36 |     if (TT.x) rc = (h ? lremovexattr : removexattr)(*s, TT.x);
37 |     else rc = (h ? lsetxattr : setxattr)(*s, TT.n, TT.v, TT.v ? strlen(TT.v) : 0, 0);
38 |     if (rc) perror_msg_raw(*s);
39 |   }
40 | }
41 | 


--------------------------------------------------------------------------------
/toys/posix/mkfifo.c:
--------------------------------------------------------------------------------
 1 | /* mkfifo.c - Create FIFOs (named pipes)
 2 |  *
 3 |  * Copyright 2012 Georgi Chorbadzhiyski <georgi@unixsol.org>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/mkfifo.html
 6 | 
 7 | USE_MKFIFO(NEWTOY(mkfifo, "<1"SKIP_TOYBOX_LSM_NONE("Z:")"m:", TOYFLAG_USR|TOYFLAG_BIN|TOYFLAG_MOREHELP(!CFG_TOYBOX_LSM_NONE)))
 8 | 
 9 | config MKFIFO
10 |   bool "mkfifo"
11 |   default y
12 |   help
13 |     usage: mkfifo ![!-!Z! !C!O!N!T!E!X!T!]! [NAME...]
14 | 
15 |     Create FIFOs (named pipes).
16 |     !
17 |     !-Z	Security context
18 | */
19 | 
20 | #define FOR_mkfifo
21 | #include "toys.h"
22 | 
23 | GLOBALS(
24 |   char *m, *Z;
25 | 
26 |   mode_t mode;
27 | )
28 | 
29 | void mkfifo_main(void)
30 | {
31 |   char **s;
32 | 
33 |   TT.mode = 0666;
34 |   if (FLAG(m)) TT.mode = string_to_mode(TT.m, 0);
35 | 
36 |   if (FLAG(Z)) if (0>lsm_set_create(TT.Z)) perror_exit("-Z '%s' failed", TT.Z);
37 | 
38 |   for (s = toys.optargs; *s; s++)
39 |     if (mknod(*s, S_IFIFO | TT.mode, 0) < 0) perror_msg_raw(*s);
40 | }
41 | 


--------------------------------------------------------------------------------
/tests/setfattr.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | function clean()
 8 | {
 9 |   # The filesystem may include some extended attributes by default (for
10 |   # instance, security.selinux). Skip them.
11 |   grep -v "security\."
12 | }
13 | 
14 | mkdir attrs
15 | touch attrs/file
16 | setfattr -n user.empty attrs/file
17 | setfattr -n user.data -v hello attrs/file
18 | setfattr -n user.delete-me -v hello attrs/file
19 | 
20 | testing "-x" \
21 |     "setfattr -x user.delete-me attrs/file && getfattr attrs/file | clean" \
22 |     "# file: attrs/file\nuser.data\nuser.empty\n\n" "" ""
23 | testing "-n" "setfattr -n user.new attrs/file && getfattr -d attrs/file | clean" \
24 |     "# file: attrs/file\nuser.data=\"hello\"\nuser.empty\nuser.new\n\n" "" ""
25 | testing "-n -v" "setfattr -n user.new -v data attrs/file && getfattr -d attrs/file | clean" \
26 |     "# file: attrs/file\nuser.data=\"hello\"\nuser.empty\nuser.new=\"data\"\n\n" "" ""
27 | 
28 | rm -rf attrs
29 | 


--------------------------------------------------------------------------------
/tests/files/bc/cosine_results.txt:
--------------------------------------------------------------------------------
 1 | 1.00000000000000000000
 2 | .87758256189037271611
 3 | .54030230586813971740
 4 | -.41614683654714238699
 5 | -.98999249660044545727
 6 | .87758256189037271611
 7 | .54030230586813971740
 8 | -.41614683654714238699
 9 | -.98999249660044545727
10 | .90096886790241912623
11 | .90096886790241912623
12 | .70710678118654752440
13 | .70710678118654752440
14 | .50000000000000000000
15 | .50000000000000000000
16 | 0
17 | 0
18 | -.70710678118654752439
19 | -.70710678118654752439
20 | -1.00000000000000000000
21 | -1.00000000000000000000
22 | 0
23 | 0
24 | .70710678118654752439
25 | .70710678118654752439
26 | -.70710678118654752440
27 | -.70710678118654752440
28 | 1.00000000000000000000
29 | 1.00000000000000000000
30 | .92427123447397657316
31 | .92427123447397657316
32 | -.04198856352825241211
33 | -.04198856352825241211
34 | -.75581969921220636368
35 | -.01644924448939844182
36 | -.97280717522127222547
37 | -.92573947460230585966
38 | -.14343824233852988038
39 | .87259414746802343203
40 | .93542606623067050616
41 | -.52795540572178251550
42 | 


--------------------------------------------------------------------------------
/toys/other/chroot.c:
--------------------------------------------------------------------------------
 1 | /* chroot.c - Run command in new root directory.
 2 |  *
 3 |  * Copyright 2007 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * TODO: The test for root is "==" so root can trivially escape a chroot by
 6 |  * moving it below cwd, ala mkdir("sub"); chroot("sub"); chdir("../../../..")
 7 |  * The container guys use pivot_root() to deal with this, which does actually
 8 |  * edit mount tree. (New option? Kernel patch?)
 9 | 
10 | USE_CHROOT(NEWTOY(chroot, "^<1", TOYFLAG_USR|TOYFLAG_SBIN|TOYFLAG_ARGFAIL(125)))
11 | 
12 | config CHROOT
13 |   bool "chroot"
14 |   default y
15 |   help
16 |     usage: chroot NEWROOT [COMMAND [ARG...]]
17 | 
18 |     Run command within a new root directory. If no command, run /bin/sh.
19 | */
20 | 
21 | #include "toys.h"
22 | 
23 | void chroot_main(void)
24 | {
25 |   char *binsh[] = {"/bin/sh", "-i", 0};
26 | 
27 |   if (chdir(*toys.optargs) || chroot(".")) {
28 |     toys.exitval = 125;
29 |     perror_exit_raw(*toys.optargs);
30 |   }
31 |   if (toys.optargs[1]) xexec(toys.optargs+1);
32 |   else xexec(binsh);
33 | }
34 | 


--------------------------------------------------------------------------------
/toys/other/swapoff.c:
--------------------------------------------------------------------------------
 1 | /* swapoff.c - Disable region for swapping
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | USE_SWAPOFF(NEWTOY(swapoff, "<1>1av", TOYFLAG_SBIN|TOYFLAG_NEEDROOT))
 6 | 
 7 | config SWAPOFF
 8 |   bool "swapoff"
 9 |   default y
10 |   help
11 |     usage: swapoff FILE
12 | 
13 |     Disable swapping on a device or file.
14 | */
15 | 
16 | #define FOR_swapoff
17 | #include "toys.h"
18 | 
19 | static void xswapoff(char *str)
20 | {
21 |   if (FLAG(v)) printf("swapoff %s", str);
22 |   if (swapoff(str)) perror_msg("failed to remove swaparea");
23 | }
24 | 
25 | void swapoff_main(void)
26 | {
27 |   char *ss, *line, **args;
28 |   FILE *fp;
29 | 
30 |   if (FLAG(a) && (fp = fopen("/proc/swaps", "r"))) {
31 |     while ((line = xgetline(fp))) {
32 |       if (*line != '/' || !(ss = strchr(line, ' '))) continue;
33 |       *ss = 0;
34 |       octal_deslash(line);
35 |       xswapoff(line);
36 |       free(line);
37 |     }
38 |     fclose(fp);
39 |   }
40 |   for (args = toys.optargs; *args; args++) xswapoff(*args);
41 | }
42 | 


--------------------------------------------------------------------------------
/toys/other/lsmod.c:
--------------------------------------------------------------------------------
 1 | /* lsmod.c - Show the status of modules in the kernel
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | USE_LSMOD(NEWTOY(lsmod, NULL, TOYFLAG_SBIN))
 6 | 
 7 | config LSMOD
 8 |   bool "lsmod"
 9 |   default y
10 |   help
11 |     usage: lsmod
12 | 
13 |     Display the currently loaded modules, their sizes and their dependencies.
14 | */
15 | 
16 | #include "toys.h"
17 | 
18 | void lsmod_main(void)
19 | {
20 |   char *modfile = "/proc/modules";
21 |   FILE * file = xfopen(modfile, "r");
22 | 
23 |   xprintf("%-23s Size  Used by\n", "Module");
24 | 
25 |   while (fgets(toybuf, sizeof(toybuf), file)) {
26 |     char *name = strtok(toybuf, " "), *size = strtok(NULL, " "),
27 |          *refcnt = strtok(NULL, " "), *users = strtok(NULL, " ");
28 | 
29 |     if(users) {
30 |       int len = strlen(users)-1;
31 |       if (users[len] == ',' || users[len] == '-') users[len] = 0;
32 |       xprintf("%-19s %8s  %s %s\n", name, size, refcnt, users);
33 |     } else perror_exit("bad %s", modfile);
34 |   }
35 |   fclose(file);
36 | }
37 | 


--------------------------------------------------------------------------------
/tests/rev.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | echo -e "one" > file1 
 8 | echo -e "two" > file2
 9 | testing "rev" "rev && echo yes" "orez\nyes\n" "" "zero\n"
10 | toyonly testing "-" "rev - && echo yes" "orez\nyes\n" "" "zero\n"
11 | testing "file1 file2" "rev file1 file2" "eno\nowt\n" "" ""
12 | toyonly testing "- file"      "rev - file1"     "orez\neno\n" "" "zero\n"
13 | toyonly testing "file -"      "rev file1 -"     "eno\norez\n" "" "zero\n"
14 | toyonly testing "no trailing newline" "rev input" "cba\nfed\n" "abc\ndef" ""
15 | 
16 | testing "file1 notfound file2" \
17 |         "rev file1 notfound file2 2>stderr && echo ok ; grep -o 'notfound: No such file or directory' stderr; rm stderr" \
18 |         "eno\nowt\nnotfound: No such file or directory\n" "" ""
19 | 
20 | testing "different input sizes"\
21 |         "rev"\
22 |         "\n1\n21\n321\n4321\n54321\n4321\n321\n21\n1\n\n"\
23 |         "" "\n1\n12\n123\n1234\n12345\n1234\n123\n12\n1\n\n"
24 | 
25 | rm file1 file2
26 | 


--------------------------------------------------------------------------------
/toys/example/hello.c:
--------------------------------------------------------------------------------
 1 | /* hello.c - A hello world program. (Simple template for new commands.)
 2 |  *
 3 |  * Copyright 2012 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See https://pubs.opengroup.org/onlinepubs/9799919799/utilities/
 6 |  * See http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/cmdbehav.html
 7 |  * See https://www.ietf.org/rfc/rfc3.txt
 8 |  * See https://man7.org/linux/man-pages/man1/intro.1.html
 9 |  * No standard.
10 | 
11 | USE_HELLO(NEWTOY(hello, 0, TOYFLAG_USR|TOYFLAG_BIN))
12 | 
13 | config HELLO
14 |   bool "hello"
15 |   default n
16 |   help
17 |     usage: hello
18 | 
19 |     A hello world program.
20 | 
21 |     Mostly used as a simple template for adding new commands.
22 |     Occasionally nice to smoketest kernel booting via "init=/usr/bin/hello".
23 | */
24 | 
25 | #define FOR_hello
26 | #include "toys.h"
27 | 
28 | GLOBALS(
29 |   int unused;
30 | )
31 | 
32 | void hello_main(void)
33 | {
34 |   xprintf("Hello world\n");
35 | 
36 |   // Avoid kernel panic if run as init.
37 |   if (getpid() == 1) getchar();
38 | }
39 | 


--------------------------------------------------------------------------------
/toys/other/rmmod.c:
--------------------------------------------------------------------------------
 1 | /* rmmod.c - Remove a module from the Linux kernel.
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | USE_RMMOD(NEWTOY(rmmod, "<1wf", TOYFLAG_SBIN|TOYFLAG_NEEDROOT))
 6 | 
 7 | config RMMOD
 8 |   bool "rmmod"
 9 |   default y
10 |   help
11 |     usage: rmmod [-wf] MODULE...
12 | 
13 |     Unload the given kernel modules.
14 | 
15 |     -f	Force unload of a module
16 |     -w	Wait until the module is no longer used
17 | */
18 | 
19 | #define FOR_rmmod
20 | #include "toys.h"
21 | 
22 | #define delete_module(mod, flags) syscall(__NR_delete_module, mod, flags)
23 | 
24 | void rmmod_main(void)
25 | {
26 |   char **args, *module, *s;
27 |   unsigned flags;
28 | 
29 |   for (args = toys.optargs; *args; args++) {
30 |     module = basename(*args);
31 |     // Remove .ko if present
32 |     if ((s = strend(module, ".ko"))) *s = 0;
33 | 
34 |     flags = O_NONBLOCK;
35 |     if (FLAG(f)) flags |= O_TRUNC;
36 |     if (FLAG(w)) flags &= ~O_NONBLOCK;
37 |     if (delete_module(module, flags)) perror_msg("failed to unload %s", module);
38 |   }
39 | }
40 | 


--------------------------------------------------------------------------------
/tests/id.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | # Systems with SELinux will have security context cruft,
 8 | # BSDs call the root group "wheel" instead,
 9 | # and Raspberry Pi OS has root also in the 117(lpadmin) group.
10 | CLEAN="sed 's/ context=.*//g' | sed 's/wheel/root/g' | \
11 | sed 's/117//g' | sed -E 's/\(?lpadmin\)?//g' | sed 's/[ ,]$//'"
12 | 
13 | testing "0" "id 0 | $CLEAN" "uid=0(root) gid=0(root) groups=0(root)\n" "" ""
14 | testing "root" "id root | $CLEAN" \
15 |   "uid=0(root) gid=0(root) groups=0(root)\n" "" ""
16 | testing "-G root" "id -G root | $CLEAN" "0\n" "" ""
17 | testing "-nG root" "id -nG root | $CLEAN" "root\n" "" ""
18 | testing "-g root" "id -g root" "0\n" "" ""
19 | testing "-ng root" "id -ng root | $CLEAN" "root\n" "" ""
20 | testing "-u root" "id -u root" "0\n" "" ""
21 | testing "-nu root" "id -nu root" "root\n" "" ""
22 | testing "no-such-user" "id no-such-user 2>/dev/null ; echo \$?" "1\n" "" ""
23 | testing "2147483647" "id 2147483647 2>/dev/null ; echo \$?" "1\n" "" ""
24 | 


--------------------------------------------------------------------------------
/toys/example/demo_number.c:
--------------------------------------------------------------------------------
 1 | /* demo_number.c - Expose atolx() and human_readable() for testing.
 2 |  *
 3 |  * Copyright 2015 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_DEMO_NUMBER(NEWTOY(demo_number, "D#=3<3M#<0hcdbs", TOYFLAG_BIN))
 6 | 
 7 | config DEMO_NUMBER
 8 |   bool "demo_number"
 9 |   default n
10 |   help
11 |     usage: demo_number [-hsbi] [-D LEN] NUMBER...
12 | 
13 |     -D	output field is LEN chars
14 |     -M	input units (index into bkmgtpe)
15 |     -c	Comma comma down do be do down down
16 |     -b	Use "B" for single byte units (HR_B)
17 |     -d	Decimal units
18 |     -h	Human readable
19 |     -s	Space between number and units (HR_SPACE)
20 | */
21 | 
22 | #define FOR_demo_number
23 | #include "toys.h"
24 | 
25 | GLOBALS(
26 |   long M, D;
27 | )
28 | 
29 | void demo_number_main(void)
30 | {
31 |   char **arg;
32 | 
33 |   for (arg = toys.optargs; *arg; arg++) {
34 |     long long ll = atolx(*arg);
35 | 
36 |     if (toys.optflags) {
37 |       human_readable_long(toybuf, ll, TT.D, TT.M, toys.optflags);
38 |       xputs(toybuf);
39 |     } else printf("%lld\n", ll);
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/mkroot/record-commands:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Set up command recording wrapper
 4 | 
 5 | [ -z "$WRAPDIR" ] && WRAPDIR="$PWD"/record-commands && RM=$(which rm)
 6 | [ -z "$LOGPATH" ] && export LOGPATH="$PWD"/log.txt
 7 | 
 8 | if [ ! -x "$WRAPDIR/logpath" ]
 9 | then
10 |   LOG="$(which logpath)"
11 |   mkdir -p "$WRAPDIR" || exit 1
12 |   [ -e "$LOG" ] && cp -H "$LOG" "$WRAPDIR/logpath" || { cd "$(dirname $0)/.." &&
13 |     PREFIX="$WRAPDIR/" scripts/single.sh logpath >/dev/null &&
14 |     LOG="$PWD/logpath" || exit 1; }
15 |   tr : '\n' <<< "$PATH" | while read i; do
16 |     find "$i" \( -type f -o -type l \) -maxdepth 1 -executable -exec basename {} \; | \
17 |       while read FILE; do ln -s logpath "$WRAPDIR/$FILE" 2>/dev/null; done
18 |   done
19 | fi
20 | 
21 | # Delete old log (if any)
22 | rm -f "$LOGPATH"
23 | 
24 | # When sourced, set up wrapper for current context.
25 | if [ $# -gt 0 ]
26 | then
27 |   PATH="$WRAPDIR:$PATH" "$@"
28 |   X=$?
29 |   [ -n "$RM" ] && "$RM" -rf "$WRAPDIR"
30 | 
31 |   exit $X
32 | else
33 |   echo export LOGPATH=${LOGPATH@Q} PATH=${WRAPDIR@Q}:${PATH@Q}
34 | fi
35 | 
36 | 


--------------------------------------------------------------------------------
/tests/uudecode.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "uu empty file" "uudecode -o - && echo yes" \
 8 | 	"yes\n" "" "begin 744 test\n\`\nend\n"
 9 | testing "uu 1-char" "uudecode -o -" "a" "" \
10 | 	"begin 744 test\n!80  \n\`\nend\n"
11 | testing "uu 2-char" "uudecode -o -" "ab" "" \
12 | 	"begin 744 test\n\"86( \n\`\nend\n"
13 | testing "uu 3-char" "uudecode -o -" "abc" "" \
14 | 	"begin 744 test\n#86)C\n\`\nend\n" 
15 | 
16 | testing "b64 empty file" "uudecode -o - && echo yes" \
17 |         "yes\n" "" "begin-base64 744 test\n====\n" 
18 | testing "b64 1-char" "uudecode -o -" "a" "" \
19 | 	"begin-base64 744 test\nYQ==\n====\n"
20 | testing "b64 2-char" "uudecode -o -" "ab" "" \
21 | 	"begin-base64 744 test\nYWI=\n====\n"
22 | testing "b64 3-char" "uudecode -o -" "abc" "" \
23 | 	"begin-base64 744 test\nYWJj\n====\n"
24 | 
25 | testing "filename" "uudecode && echo -ne 'abc' | cmp uudecode-fn-test - && echo -ne yes && rm uudecode-fn-test" \
26 | 	"yes" "" "begin-base64 744 uudecode-fn-test\nYWJj\n====\n"
27 | 


--------------------------------------------------------------------------------
/toys/posix/nohup.c:
--------------------------------------------------------------------------------
 1 | /* nohup.c - run commandline with SIGHUP blocked.
 2 |  *
 3 |  * Copyright 2011 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/nohup.html
 6 | 
 7 | USE_NOHUP(NEWTOY(nohup, "<1^", TOYFLAG_USR|TOYFLAG_BIN|TOYFLAG_ARGFAIL(125)))
 8 | 
 9 | config NOHUP
10 |   bool "nohup"
11 |   default y
12 |   help
13 |     usage: nohup COMMAND...
14 | 
15 |     Run a command that survives the end of its terminal.
16 | 
17 |     Redirect tty on stdin to /dev/null, tty on stdout to "nohup.out".
18 | */
19 | 
20 | #include "toys.h"
21 | 
22 | void nohup_main(void)
23 | {
24 |   xsignal(SIGHUP, SIG_IGN);
25 |   if (isatty(1)) {
26 |     close(1);
27 |     if (open("nohup.out", O_CREAT|O_APPEND|O_WRONLY, 0600) == -1) {
28 |       char *temp = getenv("HOME");
29 | 
30 |       xcreate(temp ? temp = xmprintf("%s/nohup.out", temp) : "nohup.out",
31 |         O_CREAT|O_APPEND|O_WRONLY, 0600);
32 |       free(temp);
33 |     }
34 |   }
35 |   if (isatty(0)) {
36 |     close(0);
37 |     xopen_stdio("/dev/null", O_RDONLY);
38 |   }
39 | 
40 |   xexec(toys.optargs);
41 | }
42 | 


--------------------------------------------------------------------------------
/tests/cat.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | echo "one" > file1
 8 | echo "two" > file2
 9 | testing "cat" "cat && echo yes" "oneyes\n" "" "one"
10 | testing "-" "cat - && echo yes" "oneyes\n" "" "one"
11 | testing "file1 file2" "cat file1 file2" "one\ntwo\n"  "" ""
12 | testing "- file"      "cat - file1"     "zero\none\n" "" "zero\n"
13 | testing "file -"      "cat file1 -"     "one\nzero\n" "" "zero\n"
14 | 
15 | testing "file1 notfound file2" \
16 |         "cat file1 notfound file2 2>stderr && echo ok ; cat stderr; rm stderr" \
17 |         "one\ntwo\ncat: notfound: No such file or directory\n" "" ""
18 | 
19 | testing "binary" \
20 |         'cat "$C" > file1 && cmp "$C" file1 && echo yes' "yes\n" "" ""
21 | 
22 | testing "- file1" \
23 |         "cat - file1 | diff -a -U 0 - file1 | tail -n 1" \
24 |         "-hello\n" "" "hello\n"
25 | 
26 | skipnot [ -e /dev/full ]
27 | testing "> /dev/full" \
28 |         "cat - > /dev/full 2>/dev/null || echo failed" \
29 |         "failed\n" "" "zero\n"
30 | 
31 | rm file1 file2
32 | 


--------------------------------------------------------------------------------
/tests/factor.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | toyonly testing "-32" "factor -32" "-32: -1 2 2 2 2 2\n" "" ""
 8 | toyonly testing "0" "factor 0" "0: 0\n" "" ""
 9 | toyonly testing "1" "factor 1" "1: 1\n" "" ""
10 | testing "2" "factor 2" "2: 2\n" "" ""
11 | testing "3" "factor 3" "3: 3\n" "" ""
12 | testing "4" "factor 4" "4: 2 2\n" "" ""
13 | testing "10000000017" "factor 10000000017" \
14 |         "10000000017: 3 3 3 7 7 7 1079797\n" "" ""
15 | testing "10000000018" "factor 10000000018" \
16 |         "10000000018: 2 131 521 73259\n" "" ""
17 | testing "10000000019" "factor 10000000019" \
18 |         "10000000019: 10000000019\n" "" ""
19 | 
20 | testing "3 6 from stdin" "factor" "3: 3\n6: 2 3\n" "" "3 6"
21 | testing "stdin newline" "factor" "3: 3\n6: 2 3\n" "" "3\n6\n"
22 | 
23 | toyonly testing "-h" "factor -h $(((1<<63)-26))" \
24 |   "9223372036854775782: 2 3^4 17 23 319279 456065899\n" "" ""
25 | toyonly testing "-x" "factor -x $(((1<<63)-20))" \
26 |   "7fffffffffffffec: 2 2 3 283 43f2ba978e663\n" "" ""
27 | 
28 | 


--------------------------------------------------------------------------------
/tests/files/bc/subtract_results.txt:
--------------------------------------------------------------------------------
 1 | 0
 2 | -1
 3 | 1
 4 | 0
 5 | 3
 6 | -7
 7 | -12845975916483
 8 | 2874519803456326214611
 9 | 9000000000000000000000000000000000000001
10 | 1
11 | 9000000000000000000000000000000000000000.000000000000000000000000000\
12 | 00000001
13 | .0000000000000000000000000000000001
14 | 9999999999999999999999999999999999999999.999999999999999999999999999\
15 | 99999999999999999999999999999999999999999999999999999999999
16 | 10000000000000000000000000000000000000000.99999999999999999999999999\
17 | 999999999999999999999999999999999999999999999999999999999999
18 | 10000000000000000000000000000000000000000.00000000009999999999999999\
19 | 99999999999999999999999999999999999999999999999999
20 | -8
21 | -182934721309467230894628759280719690
22 | 1245723576605103923392087218483
23 | -3455919355
24 | 2354768922.07654231707
25 | 24055908741.876523177
26 | -1879234637.082765130766
27 | .0540410979106
28 | .8091148336535
29 | -124765829345.3602790000102
30 | -10548353126734.1621370644
31 | 94875394587622.85102408852693655
32 | 48667720255646230.89000073530825656433
33 | -2038581196
34 | -2351674834
35 | 525898
36 | 0
37 | 


--------------------------------------------------------------------------------
/tests/getfattr.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | function clean()
 8 | {
 9 |   # The filesystem may include some extended attributes by default (for
10 |   # instance, security.selinux). Skip them.
11 |   grep -v "security\."
12 | }
13 | 
14 | mkdir attrs
15 | touch attrs/file
16 | setfattr -n user.empty attrs/file
17 | setfattr -n user.data -v hello attrs/file
18 | setfattr -n user.more -v world attrs/file
19 | 
20 | testing "" "getfattr attrs/file | clean" \
21 |     "# file: attrs/file\nuser.data\nuser.empty\nuser.more\n\n" "" ""
22 | testing "-d" "getfattr -d attrs/file | clean" \
23 |     "# file: attrs/file\nuser.data=\"hello\"\nuser.empty\nuser.more=\"world\"\n\n" "" ""
24 | testing "-n" "getfattr -n user.empty attrs/file" \
25 |     "# file: attrs/file\nuser.empty\n\n" "" ""
26 | testing "-d -n" "getfattr -d -n user.data attrs/file" \
27 |     "# file: attrs/file\nuser.data=\"hello\"\n\n" "" ""
28 | testing "--only-values -n" "getfattr --only-values -n user.data attrs/file" \
29 |     "hello" "" ""
30 | 
31 | rm -rf attrs
32 | 


--------------------------------------------------------------------------------
/tests/basename.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | # Removal of extra /'s
 8 | testcmd "/-only" "///////" "/\n" "" ""
 9 | testcmd "trailing /" "a//////" "a\n" "" ""
10 | testcmd "combined" "/////a///b///c///d/////" "d\n" "" ""
11 | 
12 | # Standard suffix behavior.
13 | testcmd "suffix" "a/b/c/d.suffix .suffix" "d\n" "" ""
14 | 
15 | # A suffix cannot be the entire result.
16 | testcmd "suffix=result" ".txt .txt" ".txt\n" "" ""
17 | 
18 | # Deal with suffix appearing in the filename
19 | testcmd "reappearing suffix 1" "a.txt.txt .txt" "a.txt\n" "" ""
20 | testcmd "reappearing suffix 2" "a.txt.old .txt" "a.txt.old\n" "" ""
21 | 
22 | # A suffix should be a real suffix, only a the end.
23 | testcmd "invalid suffix" "isthisasuffix? suffix" "isthisasuffix?\n" "" ""
24 | 
25 | # Zero-length suffix
26 | testcmd "zero-length suffix" "a/b/c ''" "c\n" "" ""
27 | 
28 | # -s.
29 | testcmd "-s" "-s .txt /a/b/c.txt" "c\n" "" ""
30 | testcmd "-s implies -a" "-s .txt /a/b/c.txt /a/b/d.txt" "c\nd\n" "" ""
31 | testcmd "-a" "-a /a/b/f1 /c/d/f2" "f1\nf2\n" "" ""
32 | 


--------------------------------------------------------------------------------
/tests/demo_number.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testcmd "l 1024" "-h 123456789" "118M\n" "" ""
 8 | testcmd "l 1000" "-d 123456789" "123M\n" "" ""
 9 | testcmd "s 1024" "-h 5675" "5.5K\n" "" ""
10 | testcmd "s 1000" "-d 5675" "5.6k\n" "" ""
11 | 
12 | # An example input where we give a better result than coreutils.
13 | # 267350/1024=261.08. We say 261K and coreutils says 262K.
14 | testcmd "edge case" "-h 267350" "261K\n" "" ""
15 | 
16 | testcmd "-b" "-b 123" "123B\n" "" ""
17 | testcmd "-b" "-b 123456789" "118M\n" "" ""
18 | testcmd "-s" "-s 123456789" "118 M\n" "" ""
19 | testcmd "-bs" "-bs 123456789" "118 M\n" "" ""
20 | 
21 | testcmd "units" "-b 1c 1b 1k 1kd 1m 1md 1g 1gd 1t 1td 1e 1ed" \
22 |   "1B\n512B\n1.0K\n0.9K\n1.0M\n977K\n1.0G\n954M\n1.0T\n931G\n1.0E\n888P\n" \
23 |   "" ""
24 | 
25 | testcmd "decimal units" "-d 1c 1b 1k 1kd 1m 1md 1g 1gd 1t 1td 1e 1ed" \
26 |   "1\n512\n1.0k\n1.0k\n1.0M\n1.0M\n1.0G\n1.0G\n1.1T\n1.0T\n1.1E\n1.0E\n" \
27 |   "" ""
28 | 
29 | testcmd "longer output" "-D6 123 1234567 1234567890" "123\n1206K\n1177M\n" "" ""
30 | 


--------------------------------------------------------------------------------
/toys/other/chcon.c:
--------------------------------------------------------------------------------
 1 | /* chcon.c - Change file security context
 2 |  *
 3 |  * Copyright 2014 The Android Open Source Project
 4 | 
 5 | USE_CHCON(NEWTOY(chcon, "<2hvR", TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config CHCON
 8 |   bool "chcon"
 9 |   depends on TOYBOX_SELINUX
10 |   default y
11 |   help
12 |     usage: chcon [-hRv] CONTEXT FILE...
13 | 
14 |     Change the SELinux security context of listed file[s].
15 | 
16 |     -h	Change symlinks instead of what they point to
17 |     -R	Recurse into subdirectories
18 |     -v	Verbose
19 | */
20 | 
21 | #define FOR_chcon
22 | #include "toys.h"
23 | 
24 | static int do_chcon(struct dirtree *try)
25 | {
26 |   char *path, *con = *toys.optargs;
27 | 
28 |   if (!dirtree_notdotdot(try)) return 0;
29 | 
30 |   path = dirtree_path(try, 0);
31 |   if (FLAG(v)) printf("chcon '%s' to %s\n", path, con);
32 |   if (-1 == (FLAG(h) ? lsetfilecon : setfilecon)(path, con))
33 |     perror_msg("'%s' to %s", path, con);
34 |   free(path);
35 | 
36 |   return FLAG(R)*DIRTREE_RECURSE;
37 | }
38 | 
39 | void chcon_main(void)
40 | {
41 |   char **file;
42 | 
43 |   for (file = toys.optargs+1; *file; file++) dirtree_read(*file, do_chcon);
44 | }
45 | 


--------------------------------------------------------------------------------
/tests/mkpasswd.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | # TODO: migrate to internal hashes. Not sure I'm bothering with DES, so
 8 | # this (currently) only tests md5, sha256, and sha512.
 9 | # The -P0 is because debian's version misbehaves without it.
10 | testcmd 'md5' '-P0 -mmd5 -S abcdefgh' '$1$abcdefgh$G//4keteveJp0qb8z2DxG/\n' \
11 |   '' 'password'
12 | # No idea why debian's requires the dash in sha-256?
13 | testcmd 'sha256-8' '-P0 -msha-256 -S abcdefgh' \
14 |   '$5$abcdefgh$ZLdkj8mkc2XVSrPVjskDAgZPGjtj1VGVaa1aUkrMTU/\n' '' 'password'
15 | testcmd 'sha256-16' '-P0 -msha-256 -S ./Aa0Bb1Cc2Dd3Ee' \
16 |   '$5$./Aa0Bb1Cc2Dd3Ee$5iXcesTggTRGvAAa3cWlpxmUqNGOeQh/iO3Furo4y/D\n' '' \
17 |   'password'
18 | testcmd 'sha512-8' '-P0 -msha-512 -S abcdefgh' \
19 |   '$6$abcdefgh$yVfUwsw5T.JApa8POvClA1pQ5peiq97DUNyXCZN5IrF.BMSkiaLQ5kvpuEm/VQ1Tvh/KV2TcaWh8qinoW5dhA1\n' \
20 |   '' 'password'
21 | testcmd 'sha512-16' '-P0 -msha-512 -S ./Aa0Bb1Cc2Dd3Ee' \
22 |   '$6$./Aa0Bb1Cc2Dd3Ee$PvmedaPf329sM25Jn2jv3MsfK9DaDh6tyVtJucp35A/Lmrtp9g1Ab35Mr59pkuMU3QJlbXYoWJFaxyD4OwIZ60\n' \
23 |   '' 'password'
24 | 


--------------------------------------------------------------------------------
/toys/posix/nice.c:
--------------------------------------------------------------------------------
 1 | /* nice.c - Run a program at a different niceness level.
 2 |  *
 3 |  * Copyright 2010 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/nice.html
 6 | 
 7 | USE_NICE(NEWTOY(nice, "^<1n#", TOYFLAG_BIN))
 8 | 
 9 | config NICE
10 |   bool "nice"
11 |   default y
12 |   help
13 |     usage: nice [-n PRIORITY] COMMAND...
14 | 
15 |     Run a command line at an increased or decreased scheduling priority.
16 | 
17 |     Higher numbers make a program yield more CPU time, from -20 (highest
18 |     priority) to 19 (lowest).  By default processes inherit their parent's
19 |     niceness (usually 0).  By default this command adds 10 to the parent's
20 |     priority.  Only root can set a negative niceness level.
21 | 
22 |     -n	Add given adjustment to priority (default 10)
23 | */
24 | 
25 | #define FOR_nice
26 | #include "toys.h"
27 | 
28 | GLOBALS(
29 |   long n;
30 | )
31 | 
32 | void nice_main(void)
33 | {
34 |   if (!toys.optflags) TT.n = 10;
35 | 
36 |   errno = 0;
37 |   if (nice(TT.n)==-1 && errno) {
38 |     toys.exitval = 125;
39 |     perror_exit("Can't set priority");
40 |   }
41 |   xexec(toys.optargs);
42 | }
43 | 


--------------------------------------------------------------------------------
/toys/lsb/pidof.c:
--------------------------------------------------------------------------------
 1 | /* pidof.c - Print the Process IDs of all processes with the given names.
 2 |  *
 3 |  * Copyright 2012 Andreas Heck <aheck@gmx.de>
 4 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 5 |  *
 6 |  * http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/pidof.html
 7 | 
 8 | USE_PIDOF(NEWTOY(pidof, "so:x", TOYFLAG_BIN))
 9 | 
10 | config PIDOF
11 |   bool "pidof"
12 |   default y
13 |   help
14 |     usage: pidof [-s] [-o omitpid[,omitpid...]] [NAME...]
15 | 
16 |     Print the PIDs of all processes with the given names.
17 | 
18 |     -o	Omit PID(s)
19 |     -s	Single shot, only return one pid
20 |     -x	Match shell scripts too
21 | */
22 | 
23 | #define FOR_pidof
24 | #include "toys.h"
25 | 
26 | GLOBALS(
27 |   char *o;
28 | )
29 | 
30 | static int print_pid(pid_t pid, char *name)
31 | {
32 |   sprintf(toybuf, "%d", (int)pid);
33 |   if (comma_scan(TT.o, toybuf, 0)) return 0;
34 |   xprintf(" %s"+!!toys.exitval, toybuf);
35 |   toys.exitval = 0;
36 | 
37 |   return FLAG(s);
38 | }
39 | 
40 | void pidof_main(void)
41 | {
42 |   toys.exitval = 1;
43 |   names_to_pid(toys.optargs, print_pid, FLAG(x));
44 |   if (!toys.exitval) xputc('\n');
45 | }
46 | 


--------------------------------------------------------------------------------
/toys/posix/who.c:
--------------------------------------------------------------------------------
 1 | /* who.c - display who is on the system
 2 |  *
 3 |  * Copyright 2012 ProFUSION Embedded Systems
 4 |  *
 5 |  * by Luis Felipe Strano Moraes <lfelipe@profusion.mobi>
 6 |  *
 7 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/who.html
 8 |  *
 9 |  * Posix says to support many options (-abdHlmpqrstTu) but this
10 |  * isn't aimed at minicomputers with modem pools.
11 |  *
12 |  * TODO: -a doesn't know how to format other entries
13 | 
14 | USE_WHO(NEWTOY(who, "a", TOYFLAG_USR|TOYFLAG_BIN))
15 | 
16 | config WHO
17 |   bool "who"
18 |   default y
19 |   help
20 |     usage: who
21 | 
22 |     Print information about logged in users.
23 | */
24 | 
25 | #define FOR_who
26 | #include "toys.h"
27 | 
28 | void who_main(void)
29 | {
30 |   struct utmpx *entry;
31 | 
32 |   setutxent();
33 |   while ((entry = getutxent())) {
34 |     if (FLAG(a) || entry->ut_type == USER_PROCESS) {
35 |       time_t t = entry->ut_tv.tv_sec;
36 |       struct tm *tm = localtime(&t);
37 | 
38 |       strftime(toybuf, sizeof(toybuf), "%F %H:%M", tm);
39 |       printf("%s\t%s\t%s (%s)\n", entry->ut_user, entry->ut_line,
40 |         toybuf, entry->ut_host);
41 |     }
42 |   }
43 |   endutxent();
44 | }
45 | 


--------------------------------------------------------------------------------
/toys/posix/basename.c:
--------------------------------------------------------------------------------
 1 | /* basename.c - Return non-directory portion of a pathname
 2 |  *
 3 |  * Copyright 2012 Tryn Mirell <tryn@mirell.org>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/basename.html
 6 | 
 7 | 
 8 | USE_BASENAME(NEWTOY(basename, "^<1as:", TOYFLAG_USR|TOYFLAG_BIN))
 9 | 
10 | config BASENAME
11 |   bool "basename"
12 |   default y
13 |   help
14 |     usage: basename [-a] [-s SUFFIX] NAME... | NAME [SUFFIX]
15 | 
16 |     Return non-directory portion of a pathname removing suffix.
17 | 
18 |     -a		All arguments are names
19 |     -s SUFFIX	Remove suffix (implies -a)
20 | */
21 | 
22 | #define FOR_basename
23 | #include "toys.h"
24 | 
25 | GLOBALS(
26 |   char *s;
27 | )
28 | 
29 | void basename_main(void)
30 | {
31 |   char **arg, *base, *p;
32 | 
33 |   if (FLAG(s)) toys.optflags |= FLAG_a;
34 | 
35 |   if (!FLAG(a)) {
36 |     if (toys.optc>2) error_exit("too many args");
37 |     TT.s = toys.optargs[1];
38 |     toys.optargs[1] = 0;
39 |   }
40 | 
41 |   for (arg = toys.optargs; *arg; ++arg) {
42 |     // Chop off the suffix if provided.
43 |     base = basename(*arg);
44 |     if (TT.s && *TT.s && (p = strend(base, TT.s))) *p = 0;
45 |     puts(base);
46 |   }
47 | }
48 | 


--------------------------------------------------------------------------------
/tests/tac.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | 
 8 | echo -e "one-A\none-B" > file1 
 9 | echo -e "two-A\ntwo-B" > file2
10 | testing "tac" "tac && echo yes" "one-B\none-A\nyes\n" "" "one-A\none-B\n"
11 | testing "-" "tac - && echo yes" "one-B\none-A\nyes\n" "" "one-A\none-B\n"
12 | testing "file1 file2" "tac file1 file2" "one-B\none-A\ntwo-B\ntwo-A\n"  "" ""
13 | testing "- file"      "tac - file1"     "zero-B\nzero-A\none-B\none-A\n" "" "zero-A\nzero-B\n"
14 | testing "file -"      "tac file1 -"     "one-B\none-A\nzero-B\nzero-A\n" "" "zero-A\nzero-B\n"
15 | 
16 | testing "file1 notfound file2" \
17 |         "tac file1 notfound file2 2>stderr && echo ok ; tac stderr; rm stderr" \
18 |         "one-B\none-A\ntwo-B\ntwo-A\ntac: notfound: No such file or directory\n" "" ""
19 | 
20 | testing "no trailing newline" "tac -" "defabc\n" "" "abc\ndef"
21 | 
22 | # xputs used by tac does not propagate this error condition properly. 
23 | #testing "> /dev/full" \
24 | #        "tac - > /dev/full 2>stderr && echo ok; cat stderr; rm stderr" \
25 | #        "tac: write: No space left on device\n" "" "zero\n"
26 | 
27 | # 
28 | 
29 | rm file1 file2


--------------------------------------------------------------------------------
/tests/strings.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "stdin" "strings" "foobar\n" "" "foobar\n"
 8 | testing "file" "strings input" "foobar\n" "foobar\n" ""
 9 | testing "string to the end" "strings input" "foobar\n" "foobar" ""
10 | testing "short strings" "strings input" "" "foo\nbar\n" ""
11 | testing "-n6" "strings -n6 input" "foobar\n" "foobar\nbaz\n" ""
12 | testing "string and nulls" "strings input" "foobar\nbazfoo\n" \
13 | 	"\0foobar\0\0bazfoo\0foo" ""
14 | testing "-f" "strings -f input" "input: foobar\n" "foobar\n" ""
15 | testing "-o" "strings -o input | sed 's/^ *//'" "6 foobar\n" \
16 | 	"\0\0\0\0\0\0foobar\n" ""
17 | testing "-o, multiple strings" "strings -n3 -o input | sed 's/^ *//'" \
18 | 	"1 foo\n7 bar\n" "\0foo\0b\0bar\n" ""
19 | testing "-fo" "strings -fo input | sed 's/: */: /'" "input: 6 foobar\n" \
20 | 	"\0\0\0\0\0\0foobar\n" ""
21 | 
22 | OFFSET_10="\0\0\0\0\0\0\0\0\0\0foobar\n"
23 | testing "-t o" "strings -t o | sed 's/^ *//'" "12 foobar\n" "" $OFFSET_10
24 | testing "-t d" "strings -t d | sed 's/^ *//'" "10 foobar\n" "" $OFFSET_10
25 | testing "-t x" "strings -t x | sed 's/^ *//'" "a foobar\n" "" $OFFSET_10
26 | 


--------------------------------------------------------------------------------
/toys/posix/renice.c:
--------------------------------------------------------------------------------
 1 | /* renice.c - renice process
 2 |  *
 3 |  * Copyright 2013 CE Strake <strake888 at gmail.com>
 4 |  *
 5 |  * See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/renice.html
 6 | 
 7 | USE_RENICE(NEWTOY(renice, "<1gpun#|", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config RENICE
10 |   bool "renice"
11 |   default y
12 |   help
13 |     usage: renice [-gpu] -n INCREMENT ID...
14 | 
15 |     -g	Group ids
16 |     -p	Process ids (default)
17 |     -u	User ids
18 | */
19 | 
20 | #define FOR_renice
21 | #include "toys.h"
22 | 
23 | GLOBALS(
24 |   long n;
25 | )
26 | 
27 | void renice_main(void) {
28 |   int which = FLAG(g) ? PRIO_PGRP : (FLAG(u) ? PRIO_USER : PRIO_PROCESS);
29 |   char **arg;
30 | 
31 |   for (arg = toys.optargs; *arg; arg++) {
32 |     char *s = *arg;
33 |     int id = -1;
34 | 
35 |     if (FLAG(u)) {
36 |       struct passwd *p = getpwnam(s);
37 |       if (p) id = p->pw_uid;
38 |     } else {
39 |       id = strtol(s, &s, 10);
40 |       if (*s) id = -1;
41 |     }
42 | 
43 |     if (id < 0) {
44 |       error_msg("bad '%s'", *arg);
45 |       continue;
46 |     }
47 | 
48 |     if (setpriority(which, id, getpriority(which, id)+TT.n) < 0)
49 |       perror_msg("setpriority %d", id);
50 |   }
51 | }
52 | 


--------------------------------------------------------------------------------
/tests/split.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testing "split" "seq 1 12345 | split && ls xa[a-z] | wc -l" "13\n" "" ""
 8 | rm -f xa[a-z]
 9 | 
10 | testing "-" "seq 1 12345 | split - && ls xa[a-z] | wc -l" "13\n" "" ""
11 | rm -f xa[a-z]
12 | 
13 | seq 1 12345 > file
14 | testing "file" "split file && ls xa[a-z] | wc -l" "13\n" "" ""
15 | rm -f xa[a-z]
16 | 
17 | toyonly testing "-l" "split file -l 10k && wc -l xab" "2105 xab\n" "" ""
18 | rm -f xa[ab]
19 | 
20 | testing "suffix exhaustion" \
21 |   "split file -l 10 -a 1 walrus 2>/dev/null || ls walrus* | wc -l" "26\n" "" ""
22 | rm -f walrus*
23 | 
24 | testing "bytes" \
25 |   "seq 1 20000 | split -b 100 -a 3 - whang && ls whang* | wc -l && wc -c whangbpw" "1089\n94 whangbpw\n" "" ""
26 | 
27 | testing "reassembly" \
28 |   'ls whang* | sort | xargs cat > reassembled && seq 1 20000 | diff -u reassembled - && echo yes' \
29 |   "yes\n" "" ""
30 | rm -f file whang* reassembled
31 | 
32 | testing "-n" "split -n 3 input; md5sum xaa xab xac" \
33 |   "494bb8fb423bfa1a5fd66dd0b98f866d  xaa\n449acfdbc692780de30a2df05c5d32aa  xab\n15ab4be57aebe9a1e445195d5094036c  xac\n" \
34 |   "$(seq 1 10000)" ""
35 | 
36 | 


--------------------------------------------------------------------------------
/toys/posix/rmdir.c:
--------------------------------------------------------------------------------
 1 | /* rmdir.c - remove directory/path
 2 |  *
 3 |  * Copyright 2008 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/rmdir.html
 6 | 
 7 | USE_RMDIR(NEWTOY(rmdir, "<1(ignore-fail-on-non-empty)p(parents)", TOYFLAG_BIN))
 8 | 
 9 | config RMDIR
10 |   bool "rmdir"
11 |   default y
12 |   help
13 |     usage: rmdir [-p] [DIR...]
14 | 
15 |     Remove one or more directories.
16 | 
17 |     -p	Remove path
18 |     --ignore-fail-on-non-empty	Ignore failures caused by non-empty directories
19 | */
20 | 
21 | #define FOR_rmdir
22 | #include "toys.h"
23 | 
24 | static void do_rmdir(char *name)
25 | {
26 |   char *temp;
27 | 
28 |   do {
29 |     if (rmdir(name)) {
30 |       if (!FLAG(ignore_fail_on_non_empty) || errno != ENOTEMPTY)
31 |         perror_msg_raw(name);
32 |       return;
33 |     }
34 | 
35 |     // Each -p cycle back up one slash, ignoring trailing and repeated /.
36 | 
37 |     if (!toys.optflags) return;
38 |     do {
39 |       if (!(temp = strrchr(name, '/'))) return;
40 |       *temp = 0;
41 |     } while (!temp[1]);
42 |   } while (*name);
43 | }
44 | 
45 | void rmdir_main(void)
46 | {
47 |   char **s;
48 | 
49 |   for (s=toys.optargs; *s; s++) do_rmdir(*s);
50 | }
51 | 


--------------------------------------------------------------------------------
/tests/paste.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | UTFTEST="$(echo -e '\xcc\xb4\xcc\x97\xcc\x9e\xcc\xa0\x65')"
 8 | echo -e "one1\none2\none3" > one
 9 | echo -e "two1\ntwo2\ntwo3" > two
10 | touch three four
11 | echo five > five
12 | testing "" "paste one two" "one1\ttwo1\none2\ttwo2\none3\ttwo3\n" "" ""
13 | testing "" "paste -s one two" "one1\tone2\tone3\ntwo1\ttwo2\ttwo3\n" "" ""
14 | testing "" "paste -s three four" "\n\n" "" ""
15 | testing "" "paste three four" "" "" ""
16 | testing "" "paste - - -" "uno\tdos\tdesqview\nunix\t\t\n" "" "uno\ndos\ndesqview\nunix\n"
17 | testing "" "paste - - - -d ''" "unodosdesqview\nunix\n" "" "uno\ndos\ndesqview\nunix\n"
18 | testing "" "paste one two one two" \
19 |   "one1\ttwo1\tone1\ttwo1\none2\ttwo2\tone2\ttwo2\none3\ttwo3\tone3\ttwo3\n" \
20 |   "" ""
21 | testing "" "paste five three two" "five\t\ttwo1\n\t\ttwo2\n\t\ttwo3\n" "" ""
22 | testing "" "paste -d '私\0${UTFTEST}q' - - - - - - " \
23 |   "one私twothree${UTFTEST}fourqfive私six\n7私89${UTFTEST}q私\n" \
24 |   "" "one\ntwo\nthree\nfour\nfive\nsix\n7\n8\n9\n"
25 | rm -f one two three four
26 | unset UTFTEST
27 | 
28 | # test -d \n
29 | # test -d \x
30 | # test 
31 | 


--------------------------------------------------------------------------------
/tests/env.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testcmd "name "args" "result" "infile" "stdin"
 6 | #testing "name" "command" "result" "infile" "stdin"
 7 | 
 8 | export WALRUS=42 BANANA=hello LETTERS=
 9 | FILTER="| egrep '^(WALRUS|BANANA|LETTERS)=' | sort"
10 | 
11 | testcmd "read" "$FILTER" "BANANA=hello\nLETTERS=\nWALRUS=42\n" "" ""
12 | testcmd "-u" "-u BANANA $FILTER" "LETTERS=\nWALRUS=42\n" "" ""
13 | testcmd "-uu" "-u LETTERS -u WALRUS $FILTER" "BANANA=hello\n" "" ""
14 | testcmd "-i uses old \$PATH" "-i echo hello" "hello\n" "" ""
15 | testcmd "-i env" "-i env" "" "" ""
16 | testcmd "-i =" "-i one=two three=four $C | sort" \
17 |   "one=two\nthree=four\n" "" ""
18 | testcmd "-0" "-i five=six seven=eight $C -0 | sort -z" "five=six\0seven=eight\0" "" ""
19 | unset WALRUS BANANA LETTERS FILTER
20 | 
21 | testcmd "early fail" '--oops 2> /dev/null ; echo $?' "125\n" "" ""
22 | testcmd "why is this allowed" "=BLAH env | grep '^=BLAH\$'" "=BLAH\n" "" ""
23 | 
24 | testcmd "replace" "A=foo PATH= `which printenv` A" "foo\n" "" ""
25 | 
26 | # env bypasses shell builtins
27 | echo "#!$(which sh)
28 | echo \$@" > true
29 | chmod a+x true
30 | testcmd "norecurse" 'env PATH="$PWD:$PATH" true hello' "hello\n" "" ""
31 | rm true
32 | 


--------------------------------------------------------------------------------
/toys/posix/mkdir.c:
--------------------------------------------------------------------------------
 1 | /* mkdir.c - Make directories
 2 |  *
 3 |  * Copyright 2012 Georgi Chorbadzhiyski <georgi@unixsol.org>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/mkdir.html
 6 | 
 7 | USE_MKDIR(NEWTOY(mkdir, "<1"SKIP_TOYBOX_LSM_NONE("Z:")"vp(parent)(parents)m:", TOYFLAG_BIN|TOYFLAG_UMASK|TOYFLAG_MOREHELP(!CFG_TOYBOX_LSM_NONE)))
 8 | 
 9 | config MKDIR
10 |   bool "mkdir"
11 |   default y
12 |   help
13 |     usage: mkdir [-vp] ![!-!Z! !c!o!n!t!e!x!t!]! [-m MODE] [DIR...]
14 | 
15 |     Create one or more directories.
16 | 
17 |     -m	Set permissions of directory to mode
18 |     -p	Make parent directories as needed
19 |     -v	Verbose
20 |     !-Z	Set security context
21 | */
22 | 
23 | #define FOR_mkdir
24 | #include "toys.h"
25 | 
26 | GLOBALS(
27 |   char *m, *Z;
28 | )
29 | 
30 | void mkdir_main(void)
31 | {
32 |   char **s;
33 |   mode_t mode = (0777&~toys.old_umask);
34 | 
35 |   if (FLAG(Z)) if (0>lsm_set_create(TT.Z)) perror_exit("-Z '%s' failed", TT.Z);
36 | 
37 |   if (TT.m) mode = string_to_mode(TT.m, 0777);
38 | 
39 |   // Note, -p and -v flags line up with mkpathat() flags
40 |   for (s=toys.optargs; *s; s++) {
41 |     if (mkpathat(AT_FDCWD, *s, mode, toys.optflags|MKPATHAT_MKLAST))
42 |       perror_msg("'%s'", *s);
43 |   }
44 | }
45 | 


--------------------------------------------------------------------------------
/tests/files/bc/multiply_results.txt:
--------------------------------------------------------------------------------
 1 | 0
 2 | 0
 3 | 0
 4 | 0
 5 | 0
 6 | 0
 7 | 472638590273489273456
 8 | 12374861230476103672835496
 9 | 1
10 | 2
11 | 2
12 | 4
13 | 42
14 | 136
15 | 3543531533584430580556128344529291738
16 | 568600835566479683035874339053.4411638427543228060
17 | 7487566285885.8557453089005171423976251098
18 | 373846412427291014394738378015501363938345620046.7869650248829232267\
19 | 2297002026819
20 | -1
21 | -2
22 | -2751507058396910892
23 | -55374468980751.0837656919743223184
24 | -163683743464924630346895054
25 | -36888976187143312550878.567134791289418
26 | -37706154097.69662826215753378160
27 | -649904428532907022680241.94791869424754101064
28 | -290040807.350385412976669306472
29 | -.11328089187650139309272
30 | -4617316439035114.40320367843985107357898
31 | 75864709277486862054521256
32 | 10610005628108234.92015040406042336
33 | 84007879267445533366251128067927.91168012197674537856
34 | 56269158624557.1027018519702852
35 | .055305737239900889424090264801
36 | 2906048299183.472237078104362540110129
37 | 57879411419313585866282299201.3825582163029400
38 | 54512860676747314187949.9414724679950990587298071
39 | 37281153992026463004361915151761464058058.54968338992209002720
40 | 108949072447731660
41 | 63708478450213482928510139572007971.83536929222529239687
42 | 0
43 | 


--------------------------------------------------------------------------------
/tests/chown.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | if [ "$(id -u)" -ne 0 ]
 6 | then
 7 |   echo "$SHOWSKIP: chown (not root)"
 8 |   return 2>/dev/null
 9 |   exit
10 | fi
11 | 
12 | # We chown between user "root" and the last user in /etc/passwd,
13 | # and group "root" and the last group in /etc/group.
14 | USR="$(sed -n '$s/:.*//p' /etc/passwd)"
15 | GRP="$(sed -n '$s/:.*//p' /etc/group)"
16 | # Or if that fails, we assume we're on Android...
17 | : "${USR:=shell}"
18 | : "${GRP:=daemon}"
19 | 
20 | # Set up a little testing hierarchy
21 | 
22 | rm -rf testdir &&
23 | mkdir testdir &&
24 | touch testdir/file
25 | F=testdir/file
26 | 
27 | # Wrapper to reset groups and return results
28 | 
29 | OUT="&& stat --format '%U %G' $F"
30 | 
31 | #testing "name" "command" "result" "infile" "stdin"
32 | 
33 | # Basic smoketest
34 | testing "initial" "chown root:root $F $OUT" "root root\n" "" ""
35 | testing "usr:grp" "chown $USR:$GRP $F $OUT" "$USR $GRP\n" "" ""
36 | testing "root"    "chown root $F $OUT" "root $GRP\n" "" ""
37 | # TODO: can we test "owner:"?
38 | testing ":grp"    "chown root:root $F && chown :$GRP $F $OUT" \
39 |     "root $GRP\n" "" ""
40 | testing ":"       "chown $USR:$GRP $F && chown : $F $OUT" \
41 |     "$USR $GRP\n" "" ""
42 | 
43 | rm -rf testdir
44 | 


--------------------------------------------------------------------------------
/tests/losetup.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | if [ "$(id -u)" -ne 0 ]; then
 6 |   echo "$SHOWSKIP: losetup (not root)"
 7 |   return 2>/dev/null
 8 |   exit
 9 | fi
10 | 
11 | if [ "$(losetup -a | wc -l)" -ne 0 ]; then
12 |   echo "$SHOWSKIP: losetup (devices already in use)"
13 |   return 2>/dev/null
14 |   exit
15 | fi
16 | 
17 | # Android's loopback devices are only in /dev/block/loop*.
18 | # Debian has symlinks like /dev/block/7:0 back to ../loop*.
19 | if [ -b /dev/block/sda ]; then
20 |   DIR="/dev/block" # Presumably Android.
21 | else
22 |   DIR="/dev"
23 | fi
24 | 
25 | #testing "name" "command" "result" "infile" "stdin"
26 | 
27 | truncate -s 1M blah.img &&
28 | FILE="$(readlink -f blah.img)"
29 | DEV="$(stat --format %d blah.img)"
30 | NODE="$(stat --format %i blah.img)"
31 | 
32 | # TODO: assumes there are no loopback devices!
33 | testcmd "-f" "-f" "$DIR/loop0\n" "" ""
34 | testcmd "-f blah.img" "-f blah.img" "" "" ""
35 | testcmd "-f --show" "-f --show blah.img" "$DIR/loop1\n" "" ""
36 | testcmd "-a" "-a | sort" \
37 |   "$DIR/loop0: [$DEV]:$NODE ($FILE)\n$DIR/loop1: [$DEV]:$NODE ($FILE)\n" "" ""
38 | testcmd "-d $DIR/loop0" "-d $DIR/loop0 && losetup -a" \
39 |   "$DIR/loop1: [$DEV]:$NODE ($FILE)\n" "" ""
40 | testcmd "-D" "-D && losetup -a" "" "" ""
41 | 
42 | rm blah.img
43 | 


--------------------------------------------------------------------------------
/toys/other/yes.c:
--------------------------------------------------------------------------------
 1 | /* yes.c - Repeatedly output a string.
 2 |  *
 3 |  * Copyright 2007 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_YES(NEWTOY(yes, 0, TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config YES
 8 |   bool "yes"
 9 |   default y
10 |   help
11 |     usage: yes [args...]
12 | 
13 |     Repeatedly output line until killed. If no args, output 'y'.
14 | */
15 | 
16 | #include "toys.h"
17 | 
18 | void yes_main(void)
19 | {
20 |   struct iovec *iov = (void *)toybuf;
21 |   char *out, *ss;
22 |   long len, ll, i, j;
23 | 
24 |   // Collate command line arguments into one string, or repeated "y\n".
25 |   for (len = i = 0; toys.optargs[i]; i++) len += strlen(toys.optargs[i]) + 1;
26 |   ss = out = xmalloc(len ? : 128);
27 |   if (!i) for (i = 0; i<64; i++) {
28 |     *ss++ = 'y';
29 |     *ss++ = '\n';
30 |   } else {
31 |     for (i = 0; toys.optargs[i]; i++)
32 |       ss += sprintf(ss, " %s"+!i, toys.optargs[i]);
33 |     *ss++ = '\n';
34 |   }
35 | 
36 |   // Populate a redundant iovec[] outputting the same string many times
37 |   for (i = ll = 0; i<sizeof(toybuf)/sizeof(*iov); i++) {
38 |     iov[i].iov_base = out;
39 |     ll += (iov[i].iov_len = ss-out);
40 |   }
41 | 
42 |   // Writev the output until stdout stops accepting it
43 |   for (;;) for (len = 0; len<ll; len += j)
44 |     if (0>(j = writev(1, iov, i))) perror_exit(0);
45 | }
46 | 


--------------------------------------------------------------------------------
/toys/other/reboot.c:
--------------------------------------------------------------------------------
 1 | /* reboot.c - Restart, halt or powerdown the system.
 2 |  *
 3 |  * Copyright 2013 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | USE_REBOOT(NEWTOY(reboot, "d:fn", TOYFLAG_SBIN|TOYFLAG_NEEDROOT))
 6 | USE_REBOOT(OLDTOY(halt, reboot, TOYFLAG_SBIN|TOYFLAG_NEEDROOT))
 7 | USE_REBOOT(OLDTOY(poweroff, reboot, TOYFLAG_SBIN|TOYFLAG_NEEDROOT))
 8 | 
 9 | config REBOOT
10 |   bool "reboot"
11 |   default y
12 |   help
13 |     usage: reboot/halt/poweroff [-fn] [-d DELAY]
14 | 
15 |     Restart, halt, or power off the system.
16 | 
17 |     -d	Wait DELAY before proceeding (in seconds or m/h/d suffix: -d 1.5m = 90s)
18 |     -f	Force reboot (don't signal init, reboot directly)
19 |     -n	Don't sync filesystems before reboot
20 | */
21 | 
22 | #define FOR_reboot
23 | #include "toys.h"
24 | #include <sys/reboot.h>
25 | 
26 | GLOBALS(
27 |   char *d;
28 | )
29 | 
30 | void reboot_main(void)
31 | {
32 |   struct timespec ts;
33 |   int types[] = {RB_AUTOBOOT, RB_HALT_SYSTEM, RB_POWER_OFF},
34 |       sigs[] = {SIGTERM, SIGUSR1, SIGUSR2}, idx;
35 | 
36 |   if (TT.d) {
37 |     xparsetimespec(TT.d, &ts);
38 |     nanosleep(&ts, NULL);
39 |   }
40 | 
41 |   if (!FLAG(n)) sync();
42 | 
43 |   idx = stridx("hp", *toys.which->name)+1;
44 |   if (FLAG(f)) toys.exitval = reboot(types[idx]);
45 |   else toys.exitval = kill(1, sigs[idx]);
46 | }
47 | 


--------------------------------------------------------------------------------
/toys/example/demo_utf8towc.c:
--------------------------------------------------------------------------------
 1 | /* demo_utf8towc() against libc mbrtowc()
 2 |  *
 3 |  * Copyright 2017 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_DEMO_UTF8TOWC(NEWTOY(demo_utf8towc, 0, TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config DEMO_UTF8TOWC
 8 |   bool "demo_utf8towc"
 9 |   default n
10 |   help
11 |     usage: demo_utf8towc
12 | 
13 |     Print differences between toybox's utf8 conversion routines vs libc du jour.
14 | */
15 | 
16 | #include "toys.h"
17 | 
18 | void demo_utf8towc_main(void)
19 | {
20 |   mbstate_t mb;
21 |   int len1, len2, maxlen = 0;
22 |   unsigned h, u, wc2;
23 |   wchar_t wc1;
24 |   char *str = (void *)&h;
25 | 
26 |   memset(&mb, 0, sizeof(mb));
27 |   // Although there are 0x10ffff unicode points, test all 4 byte combinations.
28 |   for (u = 1; u;) {
29 |     wc1 = wc2 = 0;
30 |     len2 = 4;
31 | 
32 |     h = SWAP_BE32(u);
33 |     len1 = mbrtowc(&wc1, str, len2, &mb);
34 |     if (len1<0) memset(&mb, 0, sizeof(mb));
35 |     len2 = utf8towc(&wc2, str, len2);
36 | 
37 |     if (wcwidth(wc2)>maxlen) maxlen = wcwidth(wc2);
38 |     if (len1 != len2 || wc1 != wc2)
39 |       printf("%x %d %x %d %x\n", u++, len1, wc1, len2, wc2);
40 |     else if (len2<1) u++;
41 |     else {
42 |       h = 1<<(8*(4-len2));
43 |       u &= ~(h-1);
44 |       u += h;
45 |     }
46 | 
47 |   }
48 |   dprintf(2, "maxlen=%d\n", maxlen);
49 | }
50 | 


--------------------------------------------------------------------------------
/mkroot/packages/lfs-sources:
--------------------------------------------------------------------------------
 1 | #!/bin/echo Try "mkroot/mkroot.sh lfs"
 2 | 
 3 | [ -z "$(which mksquashfs)" ] && echo "no squashfs" && exit 1
 4 | 
 5 | # Download osuosl's rollup tarball of all the LFS packages.
 6 | 
 7 | download 45a27da2ee443a8e35a7e29db8a0c6877bbb98bb \
 8 |   http://ftp.osuosl.org/pub/lfs/lfs-packages/lfs-packages-12.1.tar
 9 | 
10 | # This one's a little weird, we're creating a target-agonstic squashfs image
11 | # not part of the initramfs.
12 | 
13 | setupfor lfs-packages
14 | LFS="$OUTPUT/lfs" LFSRC="$LFS/src"
15 | rm -rf "$LFS" && mkdir -p "$LFSRC/tzdata" &&
16 | # Fixup names
17 | tar xfC tzdata*.tar.gz "$LFSRC/tzdata" && # Horrible package, no subdirectory!
18 | rm tzdata*.tar.gz &&
19 | mv {expect*,expect-0}.tar.gz &&           # broken name (no - before version)
20 | rm -f tcl*-html.tar.gz &&                 # Broken _and_ duplicate name
21 | mv {tcl*,tcl-0}.tar.gz &&
22 | mkdir sub || exit 1
23 | # extract tarballs to package name in output and apply patches (if any)
24 | for i in *.tar*; do
25 |   PKG="${i/-[0-9]*/}"
26 |   echo process $PKG
27 |   tar xfC $i sub && mv sub/* "$LFSRC/$PKG" || exit 1
28 |   for j in $PKG*.patch; do
29 |     [ -e "$j" ] && { ( cd "$LFSRC/$PKG" && patch -p1) < "$j" || exit 1 ; }
30 |   done
31 | done
32 | 
33 | # Archive the sources
34 | 
35 | mksquashfs "$LFSRC" "$TOP"/lfs.sqf -noappend -all-root >/dev/null
36 | 


--------------------------------------------------------------------------------
/tests/files/bc/modulus.txt:
--------------------------------------------------------------------------------
 1 | 1 % 1
 2 | 2 % 1
 3 | 16 % 4
 4 | 15 % 4
 5 | 17 % 4
 6 | 2389473 % 5
 7 | 39240687239 % 1
 8 | 346728934 % 23958
 9 | 3496723859067234 % 298375462837546928347623059375486
10 | -1 % 1
11 | -2 % 1
12 | -47589634875689345 % 37869235
13 | -1274852934765 % 2387628935486273546
14 | -6324758963 % 237854962
15 | 1 % -1
16 | 2 % -1
17 | 2 % -2
18 | 2 % -3
19 | 16 % 5
20 | 15 % 5
21 | 14 % 5
22 | 89237423 % -237856923854
23 | 123647238946 % -12467
24 | -1 % -1
25 | -2 % -1
26 | -2 % -2
27 | -2 % -3
28 | -13 % -7
29 | -14 % -7
30 | -15 % -7
31 | -12784956 % -32746
32 | -127849612 % -23712347682193
33 | scale = 0
34 | 1 % 1
35 | 2 % 1
36 | 16 % 4
37 | 15 % 4
38 | 17 % 4
39 | 2389473 % 5
40 | 39240687239 % 1
41 | 346728934 % 23958
42 | 3496723859067234 % 298375462837546928347623059375486
43 | -1 % 1
44 | -2 % 1
45 | -47589634875689345 % 37869235
46 | -1274852934765 % 2387628935486273546
47 | -6324758963 % 237854962
48 | 1 % -1
49 | 2 % -1
50 | 2 % -2
51 | 2 % -3
52 | 16 % 5
53 | 15 % 5
54 | 14 % 5
55 | 89237423 % -237856923854
56 | 123647238946 % -12467
57 | -1 % -1
58 | -2 % -1
59 | -2 % -2
60 | -2 % -3
61 | -13 % -7
62 | -14 % -7
63 | -15 % -7
64 | -12784956 % -32746
65 | -127849612 % -23712347682193
66 | -3191280681 % 641165986
67 | scale = 0; -899510228 % -2448300078.40314
68 | scale = 0; -7424863 % -207.2609738667
69 | scale = 0; 3769798918 % 0.6
70 | 


--------------------------------------------------------------------------------
/tests/cksum.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | 
 6 | #testing "name" "command" "result" "infile" "stdin"
 7 | 
 8 | # Default behavior on stdin and on files.
 9 | testing "on stdin" "echo -n hello | cksum" "3287646509 5\n" "" ""
10 | echo -n "hello" > tmpfile
11 | testing "on file" "cksum tmpfile" "3287646509 5 tmpfile\n" "" ""
12 | rm -f tmpfile
13 | touch one two
14 | testing "on multiple files" "cksum one two" "4294967295 0 one\n4294967295 0 two\n" "" ""
15 | rm -f one two
16 | 
17 | # Check the length suppression, both calculate the CRC on 'abc' but the second
18 | # option has length suppression on and has the length concatenated to 'abc'.
19 | testing "on abc including length" "cksum" "1219131554 3\n" "" 'abc'
20 | toyonly testing "on abc excluding length" "cksum -N" "1219131554\n" "" 'abc\x3'
21 | 
22 | # cksum on no contents gives 0xffffffff (=4294967295)
23 | testing "on no data post-inversion" "echo -n "" | cksum" "4294967295 0\n" "" ""
24 | # If we do preinversion we will then get 0.
25 | toyonly testing "on no data pre+post-inversion" "echo -n "" | cksum -P" "0 0\n" "" ""
26 | # If we skip the post-inversion we also get 0
27 | toyonly testing "on no data no inversion" "echo -n "" | cksum -I" "0 0\n" "" ""
28 | # Two wrongs make a right.
29 | toyonly testing "on no data pre-inversion" "echo -n "" | cksum -PI" "4294967295 0\n" "" ""
30 | 


--------------------------------------------------------------------------------
/toys/other/insmod.c:
--------------------------------------------------------------------------------
 1 | /* insmod.c - Load a module into the Linux kernel.
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | USE_INSMOD(NEWTOY(insmod, "<1", TOYFLAG_SBIN|TOYFLAG_NEEDROOT))
 6 | 
 7 | config INSMOD
 8 |   bool "insmod"
 9 |   default y
10 |   help
11 |     usage: insmod MODULE [OPTION...]
12 | 
13 |     Load the module named MODULE passing options if given.
14 | */
15 | 
16 | #include "toys.h"
17 | 
18 | void insmod_main(void)
19 | {
20 |   int fd = xopenro(*toys.optargs);
21 |   int i, rc;
22 | 
23 |   i = 1;
24 |   while (toys.optargs[i] &&
25 |     strlen(toybuf) + strlen(toys.optargs[i]) + 2 < sizeof(toybuf))
26 |   {
27 |     strcat(toybuf, toys.optargs[i++]);
28 |     strcat(toybuf, " ");
29 |   }
30 | 
31 |   // finit_module doesn't work on stdin, so we fall back to init_module...
32 |   rc = syscall(SYS_finit_module, fd, toybuf, 0);
33 |   if (rc && (fd == 0 || errno == ENOSYS)) {
34 |     off_t len = 0;
35 |     char *path = !strcmp(*toys.optargs, "-") ? "/dev/stdin" : *toys.optargs;
36 |     char *buf = readfileat(AT_FDCWD, path, NULL, &len);
37 | 
38 |     if (!buf) perror_exit("couldn't read %s", path);
39 |     rc = syscall(SYS_init_module, buf, len, toybuf);
40 |     if (CFG_TOYBOX_FREE) free(buf);
41 |   }
42 | 
43 |   if (rc) perror_exit("failed to load %s", toys.optargs[0]);
44 | 
45 |   if (CFG_TOYBOX_FREE) close(fd);
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/groupdel.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Copyright 2013 Divya Kothari <divya.s.kothari@gmail.com>
 4 | # Copyright 2013 Robin Mittal <robinmittal.it@gmail.com>
 5 | 
 6 | [ -f testing.sh ] && . testing.sh
 7 | 
 8 | if [ "$(id -u)" -ne 0 ]
 9 | then
10 |   echo "$SHOWSKIP: groupdel (not root)"
11 |   return 2>/dev/null
12 |   exit
13 | fi
14 | 
15 | # Redirecting all output to /dev/null for grep and delgroup
16 | arg="&>/dev/null"
17 | 
18 | #testing "name" "command" "result" "infile" "stdin"
19 | 
20 | testing "group_name (text)" "groupadd toyTestGroup &&
21 |    grep '^toyTestGroup:' /etc/group $arg && groupdel toyTestGroup $arg &&
22 |    echo 'yes'" "yes\n" "" ""
23 | testing "group_name (alphanumeric)" "groupadd toy1Test2Group3 &&
24 |    grep '^toy1Test2Group3:' /etc/group $arg && groupdel toy1Test2Group3 $arg &&
25 |    echo 'yes'" "yes\n" "" ""
26 | testing "group_name (numeric)" "groupadd 987654321 &&
27 |    grep '^987654321:' /etc/group $arg && groupdel 987654321 $arg &&
28 |    echo 'yes'" "yes\n" "" ""
29 | testing "group_name (with ./-)" "groupadd toy.1Test-2Group.3 &&
30 |    grep '^toy.1Test-2Group.3:' /etc/group $arg &&
31 |    groupdel toy.1Test-2Group.3 $arg && echo 'yes'" "yes\n" "" ""
32 | testing "group_name with group_id" "groupadd -g 49999 toyTestGroup &&
33 |    grep '^toyTestGroup:' /etc/group $arg && groupdel toyTestGroup $arg &&
34 |    echo 'yes'" "yes\n" "" ""
35 | 


--------------------------------------------------------------------------------
/toys/other/hd.c:
--------------------------------------------------------------------------------
 1 | /* hd.c - Display traditional 16 byte/line hex+ascii.
 2 |  *
 3 |  * Copyright 2025 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * No standard
 6 | 
 7 | USE_HD(NEWTOY(hd, 0, TOYFLAG_USR|TOYFLAG_BIN|TOYFLAG_LINEBUF))
 8 | 
 9 | config HD
10 |   bool "hd"
11 |   default y
12 |   help
13 |     usage: hd [FILE...]
14 | 
15 |     Display traditional 16 byte/line ascii+hex.
16 | */
17 | 
18 | #define FOR_hd
19 | #include "toys.h"
20 | 
21 | GLOBALS(
22 |     long len;
23 |     int pos;
24 |     char flush[16];
25 | )
26 | 
27 | static void flush(void)
28 | {
29 |   int i;
30 | 
31 |   if (!TT.pos) return;
32 |   printf("%*c", 3*(17-TT.pos)+(TT.pos<8), '|');
33 |   for (i = 0; i<TT.pos; i++)
34 |     putchar((TT.flush[i]<32 || TT.flush[i]>127) ? '.' : TT.flush[i]);
35 |   printf("|\n");
36 |   TT.pos = 0;
37 | }
38 | 
39 | static void do_hd(int fd, char *name)
40 | {
41 |   int off, len;
42 | 
43 |   while (0<(len = xread(fd, toybuf, sizeof(toybuf)))) {
44 |     for (off = 0; off<len; off++) {
45 |       if (!TT.pos) printf("%08lx", TT.len);
46 |       TT.len++;
47 |       printf("  %02x"+!!(TT.pos&7), toybuf[off]);
48 |       TT.flush[TT.pos++] = toybuf[off];
49 |       if (TT.pos==16) flush();
50 |     }
51 |   }
52 | }
53 | 
54 | void hd_main(void)
55 | {
56 |   int pos;
57 | 
58 |   loopfiles(toys.optargs, do_hd);
59 |   pos = TT.pos;
60 |   flush();
61 |   if (pos) printf("%08lx\n", TT.len);
62 | }
63 | 


--------------------------------------------------------------------------------
/mkroot/tar-for-web.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # tar up completed system images to send to website, with READMEs
 4 | 
 5 | rm -f root/toybox-* root/*.tgz
 6 | for i in root/*/fs/bin/toybox
 7 | do
 8 |   cp $i root/toybox-$(echo $i | sed 's@root/\([^/]*\)/.*@\1@') || exit 1
 9 | done
10 | 
11 | for i in root/*/run-qemu.sh
12 | do
13 |   i=${i%/run-qemu.sh} j=${i#root/}
14 |   [ ! -e "$i" ] && continue
15 |   # Add README, don't include "fs" dir (you can extract it from cpio.gz)
16 |   cp mkroot/README.root $i/docs/README &&
17 |   tar cvzfC $i.tgz root --exclude=fs $j || exit 1
18 | done
19 | 
20 | # Generate top level README
21 | KVERS=$(toybox sed -n '3s@# Linux/[^ ]* \(.*\) Kernel Configuration@\1@p' root/*/docs/linux-fullconfig)
22 | cat > root/README << EOF
23 | Bootable system images created by:
24 | 
25 |   mkroot/mkroot.sh LINUX=~/linux CROSS=allnonstop
26 | 
27 | Each system image is built from two packages: toybox and linux.
28 | The run-qemu.sh script in each tarball should boot the system
29 | to a shell prompt under qemu, exit from that shell to shut down the
30 | virtual system and stop the emulator.
31 | 
32 | See https://landley.net/toybox/faq.html#mkroot for details.
33 | 
34 | Built from mkroot $(git describe --tags), and Linux $KVERS with patches in linux-patches/
35 | EOF
36 | 
37 | if [ $# -eq 2 ]
38 | then
39 |   scp root/toybox-* "$1/$2/" &&
40 |   scp root/*.tgz root/README "$1/mkroot/$2/"
41 | fi
42 | 


--------------------------------------------------------------------------------
/tests/xzcat.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # Copyright 2014 Divya Kothari <divya.s.kothari@gmail.com>
 4 | # Copyright 2014 Naha Maggu <maggu.neha@gmail.com>
 5 | 
 6 | [ -f testing.sh ] && . testing.sh
 7 | 
 8 | #testing "name" "command" "result" "infile" "stdin"
 9 | echo "hello" > file
10 | tar -cJf file.xz file
11 | # Get system xzcat
12 | xzcatExe=`which xzcat`
13 | $xzcatExe file.xz > xzcatOut
14 | testcmd "- decompresses a single file" "file.xz > Tempfile && echo "yes"; diff Tempfile xzcatOut && echo "yes"; rm -rf file* xzcatOut Tempfile" "yes\nyes\n" "" ""
15 | 
16 | #testing "name" "command" "result" "infile" "stdin"
17 | echo "hello" > file1
18 | echo "hi" > file2
19 | echo "Hi, Good morning !! I am a xzcat tester" > file3
20 | tar -cJf file1.xz file1
21 | tar -cJf file2.xz file2
22 | tar -cJf file3.xz file3
23 | # Get system xzcat
24 | xzcatExe=`which xzcat`
25 | $xzcatExe file1.xz file2.xz file3.xz > xzcatOut
26 | testcmd "- decompresses multiple files" "file1.xz file2.xz file3.xz > Tempfile && echo "yes" ; diff Tempfile xzcatOut && echo "yes"; rm -rf file* xzcatOut Tempfile " "yes\nyes\n" "" ""
27 | echo "This is NOT a XZ file!!!" > file
28 | testcmd "bad file" "file 2>/dev/null || echo yes" "yes\n" "" ""
29 | echo "Surely nothing bad will happen to this compressed data!" > file
30 | tar -cJf file.xz file
31 | truncate -s 16 file.xz
32 | testcmd "corrupted file" "file.xz 2>/dev/null || echo yes" "yes\n" "" ""
33 | 


--------------------------------------------------------------------------------
/tests/taskset.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | CPUS=$(($(nproc)+0))
 8 | if [ $CPUS -lt 2 ]
 9 | then
10 |   echo "$SHOWSKIP: taskset (not SMP)"
11 |   return 2 > /dev/null
12 |   exit
13 | fi
14 | # Masks can be >64 bits but shell bitshifts usually can't
15 | MOVER= LOVER= CCNT=$CPUS
16 | while [ $CCNT -gt 8 ]; do MOVER+=ff; LOVER+=00; CCNT=$((CCNT-8)); done
17 | [ $CCNT -gt 0 ] &&
18 |   MASK=$(printf %x $(((1<<CCNT)-1)))$MOVER &&
19 |   LAST=$(printf %x $((1<<(CCNT-1))))$LOVER
20 | 
21 | testcmd 'set mask to all' '$MASK taskset -p $BASHPID | sed "s/.*: //"' "$MASK\n" '' ''
22 | testcmd 'set mask to first' '1 taskset -p $BASHPID | sed "s/.*: //"' '1\n' '' ''
23 | testcmd 'set mask to last' '$LAST taskset -p $BASHPID | sed "s/.*: //"' "$LAST\n" '' ''
24 | testcmd '-p 0 is current process' '1 taskset -p 0 | sed "s/.*: //"' '1\n' '' ''
25 | toyonly testcmd 'no arguments shows current mask' '1 taskset' '1\n' '' ''
26 | testcmd 'run on first' '1 ps -o psr= $BASHPID | xargs' '0\n' '' ''
27 | testcmd 'run on last' '$LAST ps -o psr= $BASHPID | xargs' "$((CPUS-1))\n" '' ''
28 | testcmd "long mask doesn't segfault" \
29 |   '$(printf %99999s | tr \  0)f echo; echo $?' '\n0\n' '' ''
30 | testcmd "error checking" '0 echo nope 2>/dev/null; echo $?' '1\n' '' ''
31 | testcmd "error checking2" 'walrus echo nope 2>/dev/null; echo $?' '1\n' '' ''
32 | 


--------------------------------------------------------------------------------
/toys/other/setsid.c:
--------------------------------------------------------------------------------
 1 | /* setsid.c - Run program in a new session ID.
 2 |  *
 3 |  * Copyright 2006 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_SETSID(NEWTOY(setsid, "^<1wc@d[!dc]", TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config SETSID
 8 |   bool "setsid"
 9 |   default y
10 |   help
11 |     usage: setsid [-cdw] command [args...]
12 | 
13 |     Run process in a new session.
14 | 
15 |     -d	Detach from tty
16 |     -c	Control tty (repeat to steal)
17 |     -w	Wait for child (and exit with its status)
18 | */
19 | 
20 | #define FOR_setsid
21 | #include "toys.h"
22 | 
23 | GLOBALS(
24 |   long c;
25 | )
26 | 
27 | void setsid_main(void)
28 | {
29 |   int i;
30 | 
31 |   // setsid() fails if we're already session leader, ala "exec setsid" from sh.
32 |   // Second call can't fail, so loop won't continue endlessly.
33 |   while (setsid()<0) {
34 |     pid_t pid;
35 | 
36 |     // This must be before vfork() or tcsetpgrp() will hang waiting for parent.
37 |     setpgid(0, 0);
38 | 
39 |     pid = XVFORK();
40 |     if (pid) {
41 |       i = 0;
42 |       if (FLAG(w)) {
43 |         i = 127;
44 |         if (pid>0) i = xwaitpid(pid);
45 |       }
46 |       _exit(i);
47 |     }
48 |   }
49 | 
50 |   if (FLAG(c)) {
51 |     ioctl(0, TIOCSCTTY, TT.c>1);
52 |     tcsetpgrp(0, getpid());
53 |   } if (FLAG(d) && (i = open("/dev/tty", O_RDONLY)) != -1) {
54 |     ioctl(i, TIOCNOTTY);
55 |     close(i);
56 |   }
57 |   xexec(toys.optargs);
58 | }
59 | 


--------------------------------------------------------------------------------
/toys/android/restorecon.c:
--------------------------------------------------------------------------------
 1 | /* restorecon.c - Restore default security contexts for files
 2 |  *
 3 |  * Copyright 2015 The Android Open Source Project
 4 | 
 5 | USE_RESTORECON(NEWTOY(restorecon, "<1DFnRrv", TOYFLAG_USR|TOYFLAG_SBIN))
 6 | 
 7 | config RESTORECON
 8 |   bool "restorecon"
 9 |   depends on TOYBOX_SELINUX
10 |   default y
11 |   help
12 |     usage: restorecon [-D] [-F] [-R] [-n] [-v] FILE...
13 | 
14 |     Restores the default security contexts for the given files.
15 | 
16 |     -D	Apply to /data/data too
17 |     -F	Force reset
18 |     -R	Recurse into directories
19 |     -n	Don't make any changes; useful with -v to see what would change
20 |     -v	Verbose
21 | */
22 | 
23 | #define FOR_restorecon
24 | #include "toys.h"
25 | 
26 | #if defined(__ANDROID__)
27 | #include <selinux/android.h>
28 | #endif
29 | 
30 | void restorecon_main(void)
31 | {
32 | #if defined(__ANDROID__)
33 |   char **s;
34 |   int flags = 0;
35 | 
36 |   if (FLAG(D)) flags |= SELINUX_ANDROID_RESTORECON_DATADATA;
37 |   if (FLAG(F)) flags |= SELINUX_ANDROID_RESTORECON_FORCE;
38 |   if (FLAG(R) || FLAG(r)) flags |= SELINUX_ANDROID_RESTORECON_RECURSE;
39 |   if (FLAG(n)) flags |= SELINUX_ANDROID_RESTORECON_NOCHANGE;
40 |   if (FLAG(v)) flags |= SELINUX_ANDROID_RESTORECON_VERBOSE;
41 | 
42 |   for (s = toys.optargs; *s; s++)
43 |     if (selinux_android_restorecon(*s, flags) < 0)
44 |       perror_msg("restorecon failed: %s", *s);
45 | #endif
46 | }
47 | 


--------------------------------------------------------------------------------
/toys/other/watchdog.c:
--------------------------------------------------------------------------------
 1 | /* watchdog - start a watchdog timer with configurable kick frequencies
 2 |  *
 3 |  * Copyright 2019 Chris Sarra <chrissarra@google.com>
 4 |  *
 5 |  * See kernel.org/doc/Documentation/watchdog/watchdog-api.txt
 6 | 
 7 | USE_WATCHDOG(NEWTOY(watchdog, "<1>1Ft#=4<1T#=60<1", TOYFLAG_NEEDROOT|TOYFLAG_SBIN))
 8 | 
 9 | config WATCHDOG
10 |   bool "watchdog"
11 |   default y
12 |   help
13 |     usage: watchdog [-F] [-t UPDATE] [-T DEADLINE] DEV
14 | 
15 |     Start the watchdog timer at DEV with optional timeout parameters.
16 | 
17 |     -F	run in the foreground (do not daemonize)
18 |     -t	poke watchdog every UPDATE seconds (default 4)
19 |     -T	reboot if not poked for DEADLINE seconds (default 60)
20 | */
21 | 
22 | #define FOR_watchdog
23 | #include "toys.h"
24 | #include "linux/watchdog.h"
25 | 
26 | GLOBALS(
27 |   long T, t;
28 | 
29 |   int fd;
30 | )
31 | 
32 | static void safe_shutdown(int ignored)
33 | {
34 |   (void)write(TT.fd, "V", 1);
35 |   close(TT.fd);
36 |   error_exit("safely exited watchdog.");
37 | }
38 | 
39 | void watchdog_main(void)
40 | {
41 |   if (!FLAG(F)) xvdaemon();
42 |   xsignal(SIGTERM, safe_shutdown);
43 |   xsignal(SIGINT, safe_shutdown);
44 |   xioctl(TT.fd = xopen(*toys.optargs, O_WRONLY), WDIOC_SETTIMEOUT, &TT.T);
45 | 
46 |   // Now that we've got the watchdog device open, kick it periodically.
47 |   for (;;) {
48 |     (void)write(TT.fd, "", 1);
49 |     sleep(TT.t);
50 |   }
51 | }
52 | 


--------------------------------------------------------------------------------
/tests/files/bc/boolean_results.txt:
--------------------------------------------------------------------------------
  1 | 1
  2 | 0
  3 | 0
  4 | 1
  5 | 0
  6 | 0
  7 | 1
  8 | 0
  9 | 0
 10 | 0
 11 | 0
 12 | 0
 13 | 0
 14 | 0
 15 | 0
 16 | 1
 17 | 0
 18 | 1
 19 | 0
 20 | 0
 21 | 0
 22 | 1
 23 | 0
 24 | 0
 25 | 0
 26 | 0
 27 | 0
 28 | 1
 29 | 0
 30 | 0
 31 | 0
 32 | 0
 33 | 0
 34 | 0
 35 | 0
 36 | 0
 37 | 1
 38 | 0
 39 | 0
 40 | 0
 41 | 0
 42 | 0
 43 | 0
 44 | 0
 45 | 1
 46 | 0
 47 | 0
 48 | 0
 49 | 0
 50 | 0
 51 | 0
 52 | 0
 53 | 0
 54 | 1
 55 | 0
 56 | 0
 57 | 0
 58 | 0
 59 | 0
 60 | 1
 61 | 0
 62 | 0
 63 | 0
 64 | 0
 65 | 0
 66 | 0
 67 | 0
 68 | 0
 69 | 1
 70 | 1
 71 | 0
 72 | 0
 73 | 0
 74 | 0
 75 | 0
 76 | 0
 77 | 0
 78 | 0
 79 | 0
 80 | 0
 81 | 1
 82 | 1
 83 | 0
 84 | 0
 85 | 1
 86 | 0
 87 | 0
 88 | 0
 89 | 0
 90 | 0
 91 | 0
 92 | 0
 93 | 1
 94 | 1
 95 | 1
 96 | 1
 97 | 1
 98 | 1
 99 | 1
100 | 1
101 | 1
102 | 1
103 | 1
104 | 0
105 | 1
106 | 1
107 | 1
108 | 0
109 | 1
110 | 1
111 | 1
112 | 1
113 | 1
114 | 0
115 | 1
116 | 1
117 | 1
118 | 1
119 | 1
120 | 1
121 | 1
122 | 0
123 | 1
124 | 1
125 | 1
126 | 1
127 | 0
128 | 1
129 | 1
130 | 1
131 | 1
132 | 1
133 | 0
134 | 1
135 | 1
136 | 1
137 | 1
138 | 0
139 | 1
140 | 1
141 | 1
142 | 1
143 | 1
144 | 1
145 | 1
146 | 0
147 | 1
148 | 1
149 | 1
150 | 1
151 | 0
152 | 1
153 | 1
154 | 1
155 | 1
156 | 1
157 | 1
158 | 1
159 | 1
160 | 1
161 | 1
162 | 1
163 | 1
164 | 0
165 | 0
166 | 0
167 | 0
168 | 0
169 | 0
170 | 1
171 | 1
172 | 1
173 | 1
174 | 1
175 | 1
176 | 1
177 | 0
178 | 0
179 | 1
180 | 0
181 | 0
182 | 


--------------------------------------------------------------------------------
/toys/other/mkswap.c:
--------------------------------------------------------------------------------
 1 | /* mkswap.c - Format swap device.
 2 |  *
 3 |  * Copyright 2009 Rob Landley <rob@landley.net>
 4 | 
 5 | USE_MKSWAP(NEWTOY(mkswap, "<1>1L:", TOYFLAG_SBIN))
 6 | 
 7 | config MKSWAP
 8 |   bool "mkswap"
 9 |   default y
10 |   help
11 |     usage: mkswap [-L LABEL] DEVICE
12 | 
13 |     Set up a Linux swap area on a device or file.
14 | */
15 | 
16 | #define FOR_mkswap
17 | #include "toys.h"
18 | 
19 | GLOBALS(
20 |   char *L;
21 | )
22 | 
23 | void mkswap_main(void)
24 | {
25 |   int fd = xopen(*toys.optargs, O_RDWR), pagesize = sysconf(_SC_PAGE_SIZE);
26 |   off_t len = fdlength(fd);
27 |   unsigned int pages = (len/pagesize)-1, *swap = (unsigned int *)toybuf;
28 |   char *label = (char *)(swap+7), *uuid = (char *)(swap+3);
29 | 
30 |   // Write header. Note that older kernel versions checked signature
31 |   // on disk (not in cache) during swapon, so sync after writing.
32 | 
33 |   swap[0] = 1;
34 |   swap[1] = pages;
35 |   xlseek(fd, 1024, SEEK_SET);
36 |   create_uuid(uuid);
37 |   if (TT.L) strncpy(label, TT.L, 15);
38 |   xwrite(fd, swap, 129*sizeof(unsigned int));
39 |   xlseek(fd, pagesize-10, SEEK_SET);
40 |   xwrite(fd, "SWAPSPACE2", 10);
41 |   fsync(fd);
42 | 
43 |   if (CFG_TOYBOX_FREE) close(fd);
44 | 
45 |   if (TT.L) sprintf(toybuf, ", LABEL=%.15s", TT.L);
46 |   else *toybuf = 0;
47 |   printf("Swapspace size: %luk%s, UUID=%s\n",
48 |     pages*(unsigned long)(pagesize/1024),
49 |     toybuf, show_uuid(uuid));
50 | }
51 | 


--------------------------------------------------------------------------------
/tests/files/bc/power_results.txt:
--------------------------------------------------------------------------------
 1 | 1
 2 | 0
 3 | 0
 4 | 1
 5 | 1
 6 | 1
 7 | 1
 8 | 1
 9 | 2
10 | 18927361346
11 | .23523785962738592635777
12 | 328956734869213746.89782398457234
13 | 16473742664221279051571200630760751138799221376964991600670000200609\
14 | 08006052596520320731708604393844468006290371918262741885989163144389\
15 | 39367835091560809036359941703341471396407660150658436796925310445979\
16 | 21333166245765946557344383284626113908419359990042883048537750217279\
17 | 17481980123593363177308481941550382845381799410533956718500484099889\
18 | 610805653325917409549921909941664118421333562129
19 | 0
20 | 43287877285033571298394739716218787350087163435619825150259705419.98\
21 | 016445740928054425
22 | 1.00000000000000000000
23 | .50000000000000000000
24 | .10000000000000000000
25 | .00000000146255543348
26 | .00000000002592041867
27 | 1.00000000000000000000
28 | .00000000000000011102
29 | .00000000000007327736
30 | -1
31 | 1
32 | -2
33 | 4
34 | -7373981340203217564025207502362461927230480148287479751287576522804\
35 | 77
36 | 38774140915674516674808545536
37 | -.00000000000000017759
38 | -25764707167314625311472240.23895709280819039654
39 | 128587429491381039942.88651883210401536158
40 | -1.00000000000000000000
41 | 1.00000000000000000000
42 | -.50000000000000000000
43 | .25000000000000000000
44 | 0
45 | 0
46 | -.00000000000002874159
47 | -1139873046177080922024790150196533457011720664136966.15649615964858\
48 | 379359
49 | 0
50 | 0
51 | -.00000000000000527697
52 | 


--------------------------------------------------------------------------------
/toys/posix/pwd.c:
--------------------------------------------------------------------------------
 1 | /* pwd.c - Print working directory.
 2 |  *
 3 |  * Copyright 2006 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/pwd.html
 6 | 
 7 | USE_PWD(NEWTOY(pwd, ">0LP[-LP]", TOYFLAG_BIN|TOYFLAG_MAYFORK))
 8 | 
 9 | config PWD
10 |   bool "pwd"
11 |   default y
12 |   help
13 |     usage: pwd [-L|-P]
14 | 
15 |     Print working (current) directory.
16 | 
17 |     -L	Use shell's path from $PWD (when applicable)
18 |     -P	Print canonical absolute path
19 | */
20 | 
21 | #define FOR_pwd
22 | #include "toys.h"
23 | 
24 | void pwd_main(void)
25 | {
26 |   char *s, *pwd = getcwd(0, 0), *PWD;
27 | 
28 |   // Only use $PWD if it's an absolute path alias for cwd with no "." or ".."
29 |   if (!FLAG(P) && (s = PWD = getenv("PWD"))) {
30 |     struct stat st1, st2;
31 | 
32 |     while (*s == '/') {
33 |       if (*(++s) == '.') {
34 |         if (s[1] == '/' || !s[1]) break;
35 |         if (s[1] == '.' && (s[2] == '/' || !s[2])) break;
36 |       }
37 |       while (*s && *s != '/') s++;
38 |     }
39 |     if (!*s && s != PWD) s = PWD;
40 |     else s = 0;
41 | 
42 |     // If current directory exists, make sure it matches.
43 |     if (s && pwd)
44 |       if (stat(pwd, &st1) || stat(PWD, &st2) || !same_file(&st1, &st2)) s = 0;
45 |   } else s = 0;
46 | 
47 |   // If -L didn't give us a valid path, use cwd.
48 |   if (s || (s = pwd)) puts(s);
49 |   free(pwd);
50 |   if (!s) perror_exit("xgetcwd");
51 | }
52 | 


--------------------------------------------------------------------------------
/tests/fold.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testcmd 'default wrap' '-w10' 'one two th\nree\nfour five\n' \
 8 |   '' 'one two three\nfour five\n'
 9 | testing "abuse" "fold -w1" "a\nb\nc\nd" "" "abcd"
10 | testcmd 'first char goes over' '-w2' '\t\n' '' '\t\n'
11 | testcmd 'tab goes over' '-sw2' 'a\n\t\n' '' 'a\t\n'
12 | testcmd 'tab goes over unterminated' '-sw2' 'a\n\t' '' 'a\t'
13 | testcmd '-s' '-sw4' 'abcd\nef g\n' '' 'abcdef g\n'
14 | testcmd '-s 2' '-sw4' 'abcd\nef \ngh\n' '' 'abcdef gh\n'
15 | testcmd '-s 3' '-sw4' 'a \ncd \nfgh\n' '' 'a cd fgh\n'
16 | testcmd '-s 4' '-sw4' 'abcd\n efg\n' '' 'abcd efg\n'
17 | testcmd '-s 5' '-sw4' 'abc \nef\n' '' 'abc ef\n'
18 | testcmd '-b tab' '-bw8' 'abc\tdefg\nhi' '' 'abc\tdefghi'
19 | testcmd '-bs' '-bsw8' 'abc\t\ndefghi' '' 'abc\tdefghi'
20 | testcmd 'backspace' '-w3' 'abc\bd\nef\n' '' 'abc\bdef\n'
21 | testcmd '-b backspace' '-bw3' 'abc\n\bde\nf\n' '' 'abc\bdef\n'
22 | testcmd 'backspace tab' '-w8' 'a\t\b\b\bcde\nfghi' '' 'a\t\b\b\bcdefghi'
23 | 
24 | toyonly testcmd 'combining umlaut wrap' '-w5' 'ẅabcd\nefg\n' '' \
25 |   'w\xcc\x88abcdefg\n'
26 | toyonly testcmd 'combining umlaut backspace wrap' '-w5' 'ẅ\bxabcd\nefg\n' '' \
27 |   'w\xcc\x88\bxabcdefg\n'
28 | toyonly testcmd 'wide wrap' '-w3' '私a\nbc' '' '\xe7\xa7\x81abc'
29 | toyonly testcmd 'wide combining wrap' '-w3' '私̈\bab\nc' '' \
30 |   '\xe7\xa7\x81\xcc\x88\babc'
31 | 


--------------------------------------------------------------------------------
/tests/vi.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | vitest() {
 6 |   script="$2:wq\n"
 7 |   testcmd "$1" "-s /dev/stdin input 1>/dev/null 2>/dev/null && cat input" "$4" "$3" "$script"
 8 | }
 9 | 
10 | vitest "w movement" "wxwx" "abc def ghi" "abc ef hi"
11 | vitest "e movement" "exex" "abc def ghi" "ab de ghi"
12 | # TODO vitest "b movement" '$bxbx' "abc def ghi" "abc ef hi"
13 | 
14 | vitest "dd first line ascii" "dd" "abc def\nghi jkl\n" "ghi jkl\n"
15 | # TODO vitest "dd last line ascii" "Gdd" "abc def\nghi jkl" "abc def\n"
16 | 
17 | vitest "dw first line ascii" "dw" "abc def\nghi" "def\nghi"
18 | # TODO vitest "dw last line ascii" 'G$bdw' "abc def\nghi jkl\n" "abc def\nghi \n"
19 | 
20 | vitest "D first line ascii" "llD" "abc def\nghi jkl" "ab\nghi jkl"
21 | # TODO vitest "D last line ascii" "GD" "abc def\nghi jkl" "abc def\n"
22 | 
23 | vitest "yw push ascii" "wyw2ep" "abc def ghi\n" "abc def ghidef \n"
24 | 
25 | vitest "insert start of file ascii" "ihello\x1b" "abc def" "helloabc def"
26 | # TODO vitest "insert end of file ascii" "GAhello\x1b" "abc\ndef" "abc\ndefhello"
27 | 
28 | vitest "insert multiple times ascii" "iab\x1bicd\x1bief\x1b" "xyz" "acefdbxyz"
29 | 
30 | vitest "insert multi yank move and push ascii" "ixyz\x1byyjp" \
31 |   "abc def\nghi jkl\nmno pqr\n" "xyzabc def\nghi jkl\nxyzabc def\nmno pqr\n"
32 | 
33 | testcmd "ZZ save" "-s /dev/stdin input 1>/dev/null 2>/dev/null && cat input" "helloabc def" "abc def" "ihello\x1bZZ"
34 | 


--------------------------------------------------------------------------------
/tests/files/bc/divide.txt:
--------------------------------------------------------------------------------
 1 | 0 / 1
 2 | 0 / 321566
 3 | 0 / 0.3984567238456
 4 | 1 / 1
 5 | 1 / 1287469297356
 6 | 1 / 0.2395672438567234
 7 | 1 / 237586239856.0293596728392360
 8 | 1249687284356 / 3027949207835207
 9 | 378617298617396719 / 35748521
10 | 9348576237845624358 / 0.9857829375461
11 | 35768293846193284 / 2374568947.045762839567823
12 | -78987234567812345 / 876542837618936
13 | -356789237555535468 / 0.3375273860984786903
14 | -5203475364850390 / 435742903748307.70869378534043296404530458
15 | -0.37861723347576903 / 7385770896
16 | -0.399454682043962 / 0.34824389304
17 | -0.6920414523873204 / 356489645223.76076045304879030
18 | -35872917389671.7573280963748 / 73924708
19 | -78375896314.4836709876983 / 0.78356798637817
20 | -2374123896417.143789621437581 / 347821469423789.1473856783960
21 | -896729350238549726 / -34976289345762
22 | -2374568293458762348596 / -0.8792370647234987679
23 | -237584692306721845726038 / -21783910782374529637.978102738746189024761
24 | -0.23457980123576298375682 / -1375486293874612
25 | -0.173897061862478951264 / -0.8179327486017634987516298745
26 | -0.9186739823576829347586 / -0.235678293458756239846
27 | -0.9375896183746982374568 / -13784962873546.0928729395476283745
28 | -2930754618923467.12323745862937465 / -734869238465
29 | -23745861923467.874675129834675 / -0.23542357869124756
30 | -3878923750692883.7238596702834756902 / -7384192674957215364986723.9738461923487621983
31 | 1 / 0.00000000000000000000000000000000000000000002346728372937352457354204563027
32 | 


--------------------------------------------------------------------------------
/www/release.txt:
--------------------------------------------------------------------------------
 1 | make distclean defconfig tests
 2 | news.html - release notes
 3 | Update version in toys.h and www/header.html
 4 |   - git commit toys.h www/news.html www/header.html
 5 | review/update roadmap.html
 6 | tag repo
 7 |   - git tag $VER
 8 |   - git push
 9 |   - git push --tags
10 | source tarball
11 |   git archive --prefix=toybox-$VER/ $VER | gzip -9 > toybox-$VER.tar.gz
12 |   scp toybox-$VER.tar.gz landley.net:landley.net/toybox/downloads
13 |   scp www/{news,header,roadmap}.html landley.net:landley.net/toybox/
14 | binaries
15 |   cd ../clean
16 |   git pull --tags ../toybox
17 |   mkroot/mkroot.sh CROSS=allnonstop LINUX=~/linux/linux
18 |   mkroot/testroot.sh
19 | 
20 |   ssh landley.net "mkdir -p landley.net/toybox/downloads/binaries/{,mkroot/}$VER"
21 |   mkroot/tar-for-web.sh landley.net:landley.net/toybox/downloads/binaries $VER
22 | 
23 |   ssh landley.net "cd landley.net/toybox/downloads/binaries && rm -f latest && ln -s $VER latest && cd mkroot && rm -f latest && ln -s $VER latest"
24 | 
25 |   make clean; make defconfig toybox
26 |   ./toybox help -ah > www/help.html
27 |   python scripts/mkstatus.py # it's python, not python++
28 | 
29 |   scp www/{news,help,status}.html landley.net:landley.net/toybox/
30 | 
31 | code.html
32 | Inform mailing list (with link to https://landley.net/toybox)
33 | Update #toybox topic
34 |   Toybox 0.7.3 released February 21, 2017. http://landley.net/toybox
35 | 
36 | scripts/recreate-prereq.sh
37 | 
38 | todo:
39 |   sparc, cortex-m toolchains
40 | 


--------------------------------------------------------------------------------
/tests/files/bc/add_results.txt:
--------------------------------------------------------------------------------
 1 | 0
 2 | 1
 3 | 2
 4 | 1
 5 | 7
 6 | 720
 7 | 1998
 8 | 324869359109479
 9 | 2378639108055453348401
10 | 78562139406792834691802347619083467219846713490861872324967138636055\
11 | 45508706362018540498696043776980521464405852627147161556994835657433\
12 | 00967298
13 | 1.1
14 | 1.1
15 | 37842935130118.1187478621432354
16 | 1.1
17 | 3746289134067138046.138375863945672398456712389456273486293
18 | -2
19 | -19
20 | -1287904651762470260258
21 | 100000000000000000000000000000000000000000000000000000000000.0000000\
22 | 00000000000000000000000000000000000000000000000000000000000000000000\
23 | 000000000000000000000000000000000000000000000
24 | 100000000000000000000000000000000000000000000000000000000000.0000000\
25 | 00000000000000000000000000000000000000000000000000000000000000000000\
26 | 000000000000000000000000000000000000000000000
27 | 100000000000000000000000000000000000000000000000000000000000.0000000\
28 | 00000000000000000000000000000000000000000000000000000000000000000000\
29 | 000000000000000000000000000000000000000009999
30 | 99999999999999999999999999999999999999999999999999999999999.99999999\
31 | 99999999999999999999999999999999999999999999999999000000000000000000\
32 | 00000000000000000000000000000000000000009999
33 | 99999999999999999999999999999999999990000000000000000000000.00000000\
34 | 00000000000000000000000000000000000000000000000000000000000000000000\
35 | 00000000000000000000000000000000000000009999
36 | 122761518
37 | -14338.391079082
38 | -2422295.6865057444
39 | 
40 | 


--------------------------------------------------------------------------------
/tests/base64.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testcmd "simple" "" "c2ltcGxlCg==\n" "" "simple\n"
 8 | testcmd "file" "input" "c2ltcGxlCg==\n" "simple\n" ""
 9 | testcmd "simple -d" "-d" "simple\n" "" "c2ltcGxlCg==\n"
10 | testcmd "simple -d" "-d input" "simple\n" "c2ltcGxlCg==" ""
11 | testcmd "default wrap" "" \
12 |   "V2UndmUgcmVwbGFjZWQgdGhlIGRpbGl0aGl1bSB0aGV5IG5vcm1hbGx5IHVzZSB3aXRoIEZvbGdl\ncidzIENyeXN0YWxzLg==\n" \
13 |   "" "We've replaced the dilithium they normally use with Folger's Crystals."
14 | testcmd "multiline -d " "-d" \
15 |  "We've replaced the dilithium they normally use with Folger's Crystals." "" \
16 |   "V2UndmUgcmVwbGFjZWQgdGhlIGRpbGl0aGl1bSB0aGV5IG5vcm1hbGx5IHVzZSB3aXRoIEZvbGdl\ncidzIENyeXN0YWxzLg==\n"
17 | 
18 | testcmd "-w" "-w 10" \
19 |   "TWFyY2hpbm\ncgdG8gdGhl\nIGJlYXQgb2\nYgYSBkaWZm\nZXJlbnQga2\nV0dGxlIG9m\nIGZpc2guCg\n==\n" \
20 |   "" "Marching to the beat of a different kettle of fish.\n"
21 | 
22 | testcmd "-w0" "-w0 input" \
23 |   "VmlraW5ncz8gVGhlcmUgYWluJ3Qgbm8gdmlraW5ncyBoZXJlLiBKdXN0IHVzIGhvbmVzdCBmYXJtZXJzLiBUaGUgdG93biB3YXMgYnVybmluZywgdGhlIHZpbGxhZ2VycyB3ZXJlIGRlYWQuIFRoZXkgZGlkbid0IG5lZWQgdGhvc2Ugc2hlZXAgYW55d2F5LiBUaGF0J3Mgb3VyIHN0b3J5IGFuZCB3ZSdyZSBzdGlja2luZyB0byBpdC4K" \
24 |  "Vikings? There ain't no vikings here. Just us honest farmers. The town was burning, the villagers were dead. They didn't need those sheep anyway. That's our story and we're sticking to it.\n" ""
25 | 


--------------------------------------------------------------------------------
/toys/other/ts.c:
--------------------------------------------------------------------------------
 1 | /* ts.c - timestamp input lines
 2 |  *
 3 |  * Copyright 2023 Oliver Webb <aquahobbyist@proton.me>
 4 |  *
 5 |  * No standard.
 6 | 
 7 | USE_TS(NEWTOY(ts, "ims", TOYFLAG_USR|TOYFLAG_BIN|TOYFLAG_LINEBUF))
 8 | 
 9 | config TS
10 |   bool "ts"
11 |   default y
12 |   help
13 |     usage: ts [-is] [FORMAT]
14 | 
15 |     Add timestamps to each line in pipeline. Default format without options
16 |     "%b %d %H:%M:%S", with -i or -s "%H:%M:%S".
17 | 
18 |     -i	Incremental (since previous line)
19 |     -m	Add milliseconds
20 |     -s	Since start
21 | */
22 | 
23 | #define FOR_ts
24 | #include "toys.h"
25 | 
26 | // because millitime() is monotonic, which returns uptime.
27 | static long long millinow(void)
28 | {
29 |   struct timespec ts;
30 | 
31 |   clock_gettime(CLOCK_REALTIME, &ts);
32 | 
33 |   return ts.tv_sec*1000+ts.tv_nsec/1000000;
34 | }
35 | 
36 | void ts_main(void)
37 | {
38 |   char *line, *mm = toybuf+sizeof(toybuf)-8,
39 |        *format = toys.optflags ? "%T" : "%b %d %T";
40 |   long long start = millinow(), now, diff, rel = FLAG(i) || FLAG(s);
41 |   struct tm *tm;
42 |   time_t tt;
43 | 
44 |   for (; (line = xgetline(stdin)); free(line)) {
45 |     now = millinow();
46 |     diff = now - start*rel;
47 |     if (FLAG(m)) sprintf(mm, ".%03lld", diff%1000);
48 |     tt = diff/1000;
49 |     tm = rel ? gmtime(&tt) : localtime(&tt);
50 |     if (FLAG(i)) start = now;
51 |     strftime(toybuf, sizeof(toybuf)-16, *toys.optargs ? : format, tm);
52 |     xprintf("%s%s %s\n", toybuf, mm, line);
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/tests/files/tar/long_path.tar:
--------------------------------------------------------------------------------
1 | ./PaxHeaders.8132/long_file_name____________________________________________________________________0000644000000000000000000000031213667420037030252 xustar00118 path=long_file_name______________________________________________________________________________________TRAILING
2 | 28 mtime=1591615519.6636426
3 | 28 atime=1591615519.6636426
4 | 28 ctime=1591615519.6636426
5 | long_file_name______________________________________________________________________________________0000644000175000017500000000000013667420037033623 0ustar00deepdeep00000000000000


--------------------------------------------------------------------------------
/toys/posix/uname.c:
--------------------------------------------------------------------------------
 1 | /* uname.c - return system name
 2 |  *
 3 |  * Copyright 2008 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/uname.html
 6 | 
 7 | USE_UNAME(NEWTOY(uname, "paomvrns", TOYFLAG_BIN))
 8 | USE_ARCH(NEWTOY(arch, 0, TOYFLAG_USR|TOYFLAG_BIN))
 9 | 
10 | config ARCH
11 |   bool "arch"
12 |   default y
13 |   help
14 |     usage: arch
15 | 
16 |     Print machine (hardware) name, same as uname -m.
17 | 
18 | config UNAME
19 |   bool "uname"
20 |   default y
21 |   help
22 |     usage: uname [-asnrvmo]
23 | 
24 |     Print system information.
25 | 
26 |     -s	System name
27 |     -n	Network (domain) name
28 |     -r	Kernel Release number
29 |     -v	Kernel Version
30 |     -m	Machine (hardware) name
31 |     -a	All of the above (in order)
32 | 
33 |     -o	Userspace type
34 | */
35 | 
36 | #define FOR_uname
37 | #define FORCE_FLAGS
38 | #include "toys.h"
39 | 
40 | void uname_main(void)
41 | {
42 |   int i, needspace = 0;
43 |   char *c;
44 | 
45 |   uname((void *)toybuf);
46 |   if (!toys.optflags) toys.optflags = FLAG_s;
47 |   for (i=0; i<6; i++) if (toys.optflags & ((1<<i)|FLAG_a)) {
48 |     if (i==5) c = " Toybox"+!needspace;
49 |     else {
50 |       c = toybuf+sizeof(((struct utsname *)0)->sysname)*i;
51 |       if (needspace++) *(--c)=' '; // Can't decrement first entry
52 |     }
53 |     xputsn(c);
54 |   }
55 |   if (FLAG(p)) xputsn(" unknown"+!needspace);
56 |   xputc('\n');
57 | }
58 | 
59 | void arch_main(void)
60 | {
61 |   toys.optflags = FLAG_m;
62 |   uname_main();
63 | }
64 | 


--------------------------------------------------------------------------------
/scripts/probes/bloatcheck:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | if [ $# -ne 2 ]
 4 | then
 5 |   echo "usage: bloatcheck old new"
 6 |   exit 1
 7 | fi
 8 | 
 9 | addline()
10 | {
11 |   NEXT="$(printf "%s% $((50-${#LASTNAME}))d% 10d %10d" "$LASTNAME" "$OLD" "$NEW" "$DELTA")"
12 |   [ -z "$STUFF" ] &&
13 |     STUFF="$NEXT" ||
14 |     STUFF="$(printf "%s\n%s" "$STUFF" "$NEXT")"
15 | }
16 | 
17 | do_bloatcheck()
18 | {
19 |   LASTNAME= DELTA=0 TOTAL=0 OLD=0 NEW=0 STUFF=
20 | 
21 |   printf "name% 46s% 10s% 11s\n" old new delta
22 |   echo "-----------------------------------------------------------------------"
23 |   while read a b c d
24 |   do
25 |     THISNAME=$(echo "$d" | sed 's/[.][0-9]*$//')
26 | 
27 |     if [ "$LASTNAME" != "$THISNAME" ]
28 |     then
29 |       TOTAL=$(($TOTAL+$DELTA))
30 |       [ $DELTA -ne 0 ] && addline
31 |       LASTNAME="$THISNAME"
32 |       DELTA=0
33 |       OLD=0
34 |       NEW=0
35 |     fi
36 | 
37 |     SIZE=$(printf "%d" "0x$b")
38 |     if [ "$a" == "-" ]
39 |     then
40 |       OLD=$(($OLD+$SIZE))
41 |       SIZE=$((-1*$SIZE))
42 |     else
43 |       NEW=$(($NEW+$SIZE))
44 |     fi
45 |     DELTA=$(($DELTA+$SIZE))
46 |   done
47 | 
48 |   TOTAL=$(($TOTAL+$DELTA))
49 |   [ $DELTA -ne 0 ] && addline
50 | 
51 |   echo "$STUFF" | sort -k4,4nr
52 |   echo "-----------------------------------------------------------------------"
53 |   printf "% 71d total\n" "$TOTAL"
54 | }
55 | 
56 | diff -U 0 <(nm --size-sort "$1"|sort -k 3,3) <(nm --size-sort "$2"|sort -k 3,3)\
57 |   | tail -n +3 | sed -n 's/^\([-+]\)/\1 /p' | sort -k4,4 | do_bloatcheck
58 | 


--------------------------------------------------------------------------------
/tests/truncate.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | SIZE='&& stat -c %s freep'
 8 | testing "0" "truncate -s 0 freep $SIZE" "0\n" "" ""
 9 | testing "12345" "truncate -s 12345 freep $SIZE" "12345\n" "" ""
10 | testing "1m" "truncate -s 1m freep $SIZE" "1048576\n" "" ""
11 | # We can't test against 0 because Android filesystems use an extra 4KiB for
12 | # extended attributes (SELinux). We recreate the file because macOS behavior
13 | # is a bit weird; for some file sizes (12345, in this example) blocks will
14 | # have been allocated that aren't deallocated by the 1g extension.
15 | rm freep; touch freep
16 | testing "is sparse" "truncate -s 1g freep && [ $(stat -c %b freep) -le 64 ] &&
17 |   echo okay" \
18 | 	"okay\n" "" ""
19 | testing "+" "truncate -s 1k freep && truncate -s +1k freep $SIZE" \
20 | 	"2048\n" "" ""
21 | testing "-" "truncate -s 4k freep && truncate -s -1k freep $SIZE" \
22 | 	"3072\n" "" ""
23 | testing "< hit" \
24 | 	"truncate -s 5k freep && truncate -s \<4k freep $SIZE" "4096\n" "" ""
25 | testing "< miss" \
26 | 	"truncate -s 4k freep && truncate -s \<6k freep $SIZE" "4096\n" "" ""
27 | testing "> hit" \
28 | 	"truncate -s 3k freep && truncate -s \>4k freep $SIZE" "4096\n" "" ""
29 | testing "> miss" \
30 | 	"truncate -s 4k freep && truncate -s \>2k freep $SIZE" "4096\n" "" ""
31 | testing "/" "truncate -s 7k freep && truncate -s /3k freep $SIZE" \
32 | 	"6144\n" "" ""
33 | testing "%" "truncate -s 7k freep && truncate -s %3k freep $SIZE" \
34 | 	"9216\n" "" ""
35 | 


--------------------------------------------------------------------------------
/toys/posix/uuencode.c:
--------------------------------------------------------------------------------
 1 | /* uuencode.c - uuencode / base64 encode
 2 |  *
 3 |  * Copyright 2013 Erich Plondke <toybox@erich.wreck.org>
 4 |  *
 5 |  * See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/uuencode.html
 6 | 
 7 | USE_UUENCODE(NEWTOY(uuencode, "<1>2m", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config UUENCODE
10 |   bool "uuencode"
11 |   default y
12 |   help
13 |     usage: uuencode [-m] [INFILE] ENCODE_FILENAME
14 | 
15 |     Uuencode stdin (or INFILE) to stdout, with ENCODE_FILENAME in the output.
16 | 
17 |     -m	Base64
18 | */
19 | 
20 | #define FOR_uuencode
21 | #include "toys.h"
22 | 
23 | void uuencode_main(void)
24 | {
25 |   char *name = toys.optargs[toys.optc-1], buf[(76/4)*3];
26 | 
27 |   int i, fd = 0;
28 | 
29 |   if (toys.optc > 1) fd = xopenro(toys.optargs[0]);
30 | 
31 |   base64_init(toybuf);
32 | 
33 |   xprintf("begin%s 744 %s\n", FLAG(m) ? "-base64" : "", name);
34 |   for (;;) {
35 |     char *in;
36 | 
37 |     if (!(i = xread(fd, buf, FLAG(m) ? sizeof(buf) : 45))) break;
38 | 
39 |     if (!FLAG(m)) xputc(i+32);
40 |     in = buf;
41 | 
42 |     for (in = buf; in-buf < i; ) {
43 |       int j, x, bytes = i - (in-buf);
44 | 
45 |       if (bytes > 3) bytes = 3;
46 | 
47 |       for (j = x = 0; j<4; j++) {
48 |         int out;
49 | 
50 |         if (j < bytes) x |= (*(in++) & 0x0ff) << (8*(2-j));
51 |         out = (x>>((3-j)*6)) & 0x3f;
52 |         xputc(FLAG(m) ? (j > bytes ? '=' : toybuf[out])
53 |           : (out ? out + 0x20 : 0x60));
54 |       }
55 |     }
56 |     xputc('\n');
57 |   }
58 |   xputs(FLAG(m) ? "====" : "end");
59 | }
60 | 


--------------------------------------------------------------------------------
/lib/toyflags.h:
--------------------------------------------------------------------------------
 1 | /* Flags values for the third argument of NEWTOY()
 2 |  *
 3 |  * Included from both main.c (runs in toys.h context) and scripts/install.c
 4 |  * (which may build on crazy things like macosx when cross compiling).
 5 |  */
 6 | 
 7 | // Flags describing command behavior.
 8 | 
 9 | // Where to install (toybox --long outputs absolute paths to commands)
10 | // If no location bits set, command not listed in "toybox" command's output.
11 | #define TOYFLAG_USR      (1<<0)
12 | #define TOYFLAG_BIN      (1<<1)
13 | #define TOYFLAG_SBIN     (1<<2)
14 | #define TOYMASK_LOCATION ((1<<4)-1)
15 | 
16 | // This is a shell built-in function, running in the same process context.
17 | #define TOYFLAG_NOFORK   (1<<4)
18 | #define TOYFLAG_MAYFORK  (1<<5)
19 | 
20 | // Start command with a umask of 0 (saves old umask in this.old_umask)
21 | #define TOYFLAG_UMASK    (1<<6)
22 | 
23 | // This command runs as root.
24 | #define TOYFLAG_STAYROOT (1<<7) // Don't drop suid root before running cmd_main
25 | #define TOYFLAG_NEEDROOT (1<<8) // Refuse to run if real uid != 0
26 | #define TOYFLAG_ROOTONLY (TOYFLAG_STAYROOT|TOYFLAG_NEEDROOT)
27 | 
28 | // Suppress default --help processing
29 | #define TOYFLAG_NOHELP   (1<<9)
30 | #define TOYFLAG_AUTOCONF (1<<10)
31 | #define TOYFLAG_TRIMHELP (1<<11)
32 | #define TOYFLAG_BIGHELP  (1<<12)
33 | #define TOYFLAG_MOREHELP(x) (TOYFLAG_TRIMHELP|TOYFLAG_BIGHELP*(x))
34 | 
35 | // Line buffered stdout
36 | #define TOYFLAG_LINEBUF  (1<<13)
37 | #define TOYFLAG_NOBUF    (1<<14)
38 | 
39 | // Error code to return if argument parsing fails (default 1)
40 | #define TOYFLAG_ARGFAIL(x) (x<<24)
41 | 


--------------------------------------------------------------------------------
/tests/expand.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | # POSIX 2008 compliant expand tests.
 4 | # Copyright 2012 by Jonathan Clairembault <jonathan@clairembault.fr>
 5 | 
 6 | [ -f testing.sh ] && . testing.sh
 7 | 
 8 | # some basic tests
 9 | 
10 | testing "default" "expand input" "        foo     bar\n" "\tfoo\tbar\n" ""
11 | testing "default stdin" "expand"  "        foo     bar\n" "" "\tfoo\tbar\n"
12 | testing "single" "expand -t 2 input" "  foo bar\n" "\tfoo\tbar\n" ""
13 | testing "tablist" "expand -t 5,10,12 input" "     foo  bar foo\n" "\tfoo\tbar\tfoo\n" ""
14 | testing "backspace" "expand input" "foobarfoo\b\b bar\n" "foobarfoo\b\b\tbar\n" ""
15 | 
16 | # advanced tests
17 | 
18 | POW=15
19 | TABSTOP=1
20 | BIGTAB=" "
21 | for i in $(seq $POW); do
22 |     BIGTAB=$BIGTAB$BIGTAB
23 |     TABSTOP=$(($TABSTOP*2))
24 | done
25 | testing "long tab single" "expand -t $TABSTOP input" "${BIGTAB}foo\n" "\tfoo\n" ""
26 | testing "long tab tablist" "expand -t $TABSTOP,$((TABSTOP+5)) input" \
27 |         "${BIGTAB}foo  bar\n" "\tfoo\tbar\n" ""
28 | 
29 | testing "multiline single" "expand -t 4 input" "foo \n    bar\n" "foo\t\n\tbar\n" ""
30 | testing "multiline tablist" "expand -t 4,8 input" \
31 |         "foo     bar\n    bar foo\n" "foo\t\tbar\n\tbar\tfoo\n" ""
32 | POW=15
33 | BIGLINE="foo "
34 | for i in $(seq $POW); do
35 |     BIGLINE=$BIGLINE$BIGLINE
36 | done
37 | if [ $POW -gt 0 ]; then
38 |     EXPANDLINE="${BIGLINE}        foo\n"
39 | else
40 |     EXPANDLINE="${BIGLINE}    foo\n"
41 | fi
42 | BIGLINE="${BIGLINE}\tfoo\n"
43 | testing "long line single" "expand input" \
44 |         "${EXPANDLINE}" "$BIGLINE" ""
45 | 


--------------------------------------------------------------------------------
/tests/base32.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | # testing "name" "flags" "result" "infile" "stdin"
 6 | 
 7 | testcmd "simple" "" "ONUW24DMMUFA====\n" "" "simple\n"
 8 | testcmd "file" "input" "ONUW24DMMUFA====\n" "simple\n" ""
 9 | testcmd "simple -d" "-d" "simple\n" "" "ONUW24DMMUFA====\n"
10 | testcmd "file -d" "-d input" "simple\n" "ONUW24DMMUFA====" ""
11 | testcmd "default wrap" "" \
12 |   "K5SSO5TFEBZGK4DMMFRWKZBAORUGKIDENFWGS5DINF2W2IDUNBSXSIDON5ZG2YLMNR4SA5LTMUQH\nO2LUNAQEM33MM5SXEJ3TEBBXE6LTORQWY4ZO\n" \
13 |   "" "We've replaced the dilithium they normally use with Folger's Crystals."
14 | testcmd "multiline -d " "-d" \
15 |  "We've replaced the dilithium they normally use with Folger's Crystals." "" \
16 |   "K5SSO5TFEBZGK4DMMFRWKZBAORUGKIDENFWGS5DINF2W2IDUNBSXSIDON5ZG2YLMNR4SA5LTMUQH\nO2LUNAQEM33MM5SXEJ3TEBBXE6LTORQWY4ZO\n"
17 | 
18 | testcmd "-w" "-w 10" \
19 |   "JVQXEY3INF\nXGOIDUN4QH\nI2DFEBRGKY\nLUEBXWMIDB\nEBSGSZTGMV\nZGK3TUEBVW\nK5DUNRSSA3\n3GEBTGS43I\nFY======\n" \
20 |   "" "Marching to the beat of a different kettle of fish."
21 | 
22 | testcmd "-w0" "-w0 input" \
23 |   "KZUWW2LOM5ZT6ICUNBSXEZJAMFUW4J3UEBXG6IDWNFVWS3THOMQGQZLSMUXCASTVON2CA5LTEBUG63TFON2CAZTBOJWWK4TTFYQFI2DFEB2G653OEB3WC4ZAMJ2XE3TJNZTSYIDUNBSSA5TJNRWGCZ3FOJZSA53FOJSSAZDFMFSC4ICUNBSXSIDENFSG4J3UEBXGKZLEEB2GQ33TMUQHG2DFMVYCAYLOPF3WC6JOEBKGQYLUE5ZSA33VOIQHG5DPOJ4SAYLOMQQHOZJHOJSSA43UNFRWW2LOM4QHI3ZANF2C4CQ=" \
24 |  "Vikings? There ain't no vikings here. Just us honest farmers. The town was burning, the villagers were dead. They didn't need those sheep anyway. That's our story and we're sticking to it.\n" ""
25 | 


--------------------------------------------------------------------------------
/tests/files/bc/subtract.txt:
--------------------------------------------------------------------------------
 1 | 0 - 0
 2 | 0 - 1
 3 | 1 - 0
 4 | 1 - 1
 5 | 5 - 2
 6 | 2 - 9
 7 | 321974 - 12845976238457
 8 | 2874519803456710938465- 384723854
 9 | 10000000000000000000000000000000000000000 - 999999999999999999999999999999999999999
10 | 10000000000000000000000000000000000000000 - 9999999999999999999999999999999999999999
11 | 10000000000000000000000000000000000000000 - 999999999999999999999999999999999999999.99999999999999999999999999999999999
12 | 10000000000000000000000000000000000000000 - 9999999999999999999999999999999999999999.9999999999999999999999999999999999
13 | 10000000000000000000000000000000000000000 - 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000001
14 | 10000000000000000000000000000000000000001 - 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000001
15 | 10000000000000000000000000000000000000000.0000000001 - 0.0000000000000000000000000000000000000000000000000000000000000000000000000001
16 | -2 - 6
17 | -23784692345 - 182934721309467230894628735496027345
18 | -224352354962873059862 - -1245723576829456278354960278345
19 | -3468273598 - -12354243
20 | -0.92345768293 - -2354768923
21 | -712384634.123476823 - -24768293376
22 | -1879234638 - -0.917234869234
23 | -0.9172438692134 - -0.971284967124
24 | -0.1283475123465 - -0.937462346
25 | -124765829346.2837468293562 - -0.923467829346
26 | -12476829385769 - -1928476259034.8378629356
27 | -0.38476284395876345 - -94875394587623.2357869324857
28 | -4674596708467.34754789403674343567 - -48672394852354698.237548629345
29 | 979519669 - 3018100865
30 | 929002449 - 3280677283
31 | 0 - -525898
32 | 3- - -3
33 | 


--------------------------------------------------------------------------------
/tests/head.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | testcmd "stdin" "-n 1 && echo yes" "one\nyes\n" "" "one\ntwo"
 8 | testcmd "stdin via -" "-n 1 - && echo yes" "one\nyes\n" "" "one\ntwo"
 9 | testcmd "file" "input -n 1 && echo yes" "one\nyes\n" "one\ntwo" ""
10 | testcmd "-number" "-2 input && echo yes" "one\ntwo\nyes\n" \
11 | 	"one\ntwo\nthree\nfour" ""
12 | testcmd "default lines" "" "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n" "" "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12"
13 | 
14 | # coreutils & busybox name stdin as "standard input", toybox uses "-"
15 | testcmd "-v file" "-v -n 1 input" "==> input <==\none\n" "one\ntwo\n" ""
16 | testcmd "-v stdin" "-v -n 1 | sed 's/standard input/-/'" \
17 | 	"==> - <==\none\n" "" "one\ntwo\n"
18 | 
19 | testcmd "file and stdin" "-n 1 input - | sed 's/standard input/-/'" \
20 | 	"==> input <==\none\n\n==> - <==\nfoo\n" "one\ntwo\n" "foo\nbar\n"
21 | 
22 | echo "foo
23 | bar
24 | baz" > file1
25 | testcmd "multiple files" "-n 2 input file1" \
26 |   "==> input <==\none\ntwo\n\n==> file1 <==\nfoo\nbar\n" "one\ntwo\nthree\n" ""
27 | testcmd "-q, multiple files" "-q -n 2 input file1" "one\ntwo\nfoo\nbar\n" \
28 | 	"one\ntwo\nthree\n" ""
29 | rm file1
30 | 
31 | testcmd "-c 3" "-c 3" "one" "" "one\ntwo"
32 | testcmd "-c bigger than input" "-c 3" "a" "" "a"
33 | testcmd "-c 3 -n 1" "-c 3 -n 1" "one\n" "" "one\ntwo"
34 | testcmd "-n 1 -c 3" "-n 1 -c 3" "one" "" "one\ntwo"
35 | testing "unget" 'while read i; do echo =$i; head -n 1; done < input' \
36 |   '=one\ntwo\n=three\nfour\n=five\n' 'one\ntwo\nthree\nfour\nfive\n' ''
37 | 


--------------------------------------------------------------------------------
/toys/net/tunctl.c:
--------------------------------------------------------------------------------
 1 | /* tunctl.c - Control tap/tun network devices.
 2 |  *
 3 |  * Copyright 2016 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://kernel.org/doc/Documentation/networking/tuntap.txt
 6 |  *
 7 |  * This is useful for things like "kvm -netdev tap" and containers.
 8 |  * See https://landley.net/lxc/02-networking.html for example usage.
 9 |  *
10 |  * TODO: bridge mode
11 |  *  -b	bridge daemon (forwards packets between NAME and NAME2 interfaces)
12 | 
13 | 
14 | USE_TUNCTL(NEWTOY(tunctl, "<1>1t|d|u:T[!td]", TOYFLAG_USR|TOYFLAG_BIN))
15 | 
16 | config TUNCTL
17 |   bool "tunctl"
18 |   default y
19 |   help
20 |     usage: tunctl [-dtT] [-u USER] NAME
21 | 
22 |     Create and delete tun/tap virtual ethernet devices.
23 | 
24 |     -T	Use tap (ethernet frames) instead of tun (ip packets)
25 |     -d	Delete tun/tap device
26 |     -t	Create tun/tap device
27 |     -u	Set owner (user who can read/write device without root access)
28 | */
29 | 
30 | #define FOR_tunctl
31 | #include "toys.h"
32 | #include <linux/if_tun.h>
33 | 
34 | GLOBALS(
35 |   char *u;
36 | )
37 | 
38 | void tunctl_main(void)
39 | {
40 |   struct ifreq *ifr = (void *)toybuf;
41 |   uid_t u = TT.u ?  xgetuid(TT.u) : 0;
42 |   int fd = xopen("/dev/net/tun", O_RDWR);
43 | 
44 |   // Associate filehandle with device
45 |   ifr->ifr_flags = (FLAG(T) ? IFF_TUN : IFF_TAP)|IFF_NO_PI;
46 |   strncpy(ifr->ifr_name, *toys.optargs, sizeof(ifr->ifr_name));
47 |   xioctl(fd, TUNSETIFF, toybuf);
48 | 
49 |   if (FLAG(t)) {
50 |     xioctl(fd, TUNSETPERSIST, (void *)1);
51 |     xioctl(fd, TUNSETOWNER, (void *)(long)u);
52 |   } else xioctl(fd, TUNSETPERSIST, (void *)0);
53 | }
54 | 


--------------------------------------------------------------------------------
/toys/other/shuf.c:
--------------------------------------------------------------------------------
 1 | /* shuf.c - Output lines in random order.
 2 |  *
 3 |  * Copyright 2023 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See https://man7.org/linux/man-pages/man1/shuf.1.html
 6 | 
 7 | USE_SHUF(NEWTOY(shuf, "zen#<0", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config SHUF
10 |   bool "shuf"
11 |   default y
12 |   help
13 |     usage: shuf [-ze] [-n COUNT] [FILE...]
14 | 
15 |     Write lines of input to output in random order.
16 | 
17 |     -z	Input/output lines are NUL terminated.
18 |     -n	Stop after COUNT many output lines.
19 |     -e	Echo mode: arguments are inputs to shuffle, not files to read.
20 | */
21 | 
22 | #define FOR_shuf
23 | #include "toys.h"
24 | 
25 | GLOBALS(
26 |   long n;
27 | 
28 |   char **lines;
29 |   long count;
30 | )
31 | 
32 | static void do_shuf_line(char **pline, long len)
33 | {
34 |   if (!pline) return;
35 |   if (!(TT.count&255))
36 |     TT.lines = xrealloc(TT.lines, sizeof(void *)*(TT.count+256));
37 |   TT.lines[TT.count++] = *pline; // TODO: repack?
38 |   *pline = 0;
39 | }
40 | 
41 | static void do_shuf(int fd, char *name)
42 | {
43 |   do_lines(fd, '\n'*!FLAG(z), do_shuf_line);
44 | }
45 | 
46 | void shuf_main(void)
47 | {
48 |   if (FLAG(e)) {
49 |     TT.lines = toys.optargs;
50 |     TT.count = toys.optc;
51 |   } else loopfiles(toys.optargs, do_shuf);
52 | 
53 |   if (!FLAG(n) || TT.n>TT.count) TT.n = TT.count;
54 | 
55 |   srandom(millitime());
56 |   while (TT.n--) {
57 |     long ll = random()%TT.count;
58 |     writeall(1, TT.lines[ll], strlen(TT.lines[ll])+FLAG(z));
59 |     if (!FLAG(e)) free(TT.lines[ll]);
60 |     else if (!FLAG(z)) writeall(1, "\n", 1);
61 |     TT.lines[ll] = TT.lines[--TT.count];
62 |   }
63 | }
64 | 


--------------------------------------------------------------------------------
/tests/files/bc/multiply.txt:
--------------------------------------------------------------------------------
 1 | 0 * 0
 2 | 0.000 * 0
 3 | 1 * 0
 4 | 0 * 1
 5 | 0 * 2498752389672835476
 6 | 873246913745129084576134 * 0
 7 | 1 * 472638590273489273456
 8 | 12374861230476103672835496 * 1
 9 | 1 * 1
10 | 2 * 1
11 | 1 * 2
12 | 2 * 2
13 | 3 * 14
14 | 17 * 8
15 | 1892467513846753 * 1872439821374591038746
16 | 328962735862.2973546835638947635 * 1728465791348762356
17 | 38745962374538.387427384672934867234 * 0.1932476528394672837568923754
18 | 9878894576289457634856.2738627161689017387608947567654 * 37842939768237596237854203.29874372139852739126739621793162
19 | -1 * 1
20 | -1 * 2
21 | 78893457 * -34876238956
22 | 235678324957634 * -0.2349578349672389576
23 | -12849567821934 * 12738462937681
24 | 1274861293467.927843682937462 * -28935678239
25 | 2936077239872.12937462836 * -0.012842357682435762
26 | 2387692387566.2378569237546 * -272189345628.123875629835876
27 | 0.012348629356782835962 * -23487692356
28 | 0.4768349567348675934 * -0.23756834576934857638495
29 | 0.98748395367485962735486 * -4675839462354867.376834956738456
30 | -321784627934586 * -235762378596
31 | -32578623567892356 * -0.32567384579638456
32 | -35768232346876 * -2348672935602387620.28375682349576237856
33 | -0.2356728394765234 * -238759624356978
34 | -0.2345768212346780 * -0.235768124697074385948943532045
35 | -0.370873860736785306278630 * -7835678398607.7086378076867096270
36 | -78365713707.7089637863786730 * -738580798679306780
37 | -73867038956790490258249 * -0.7379862716391723672803679
38 | -378621971598721837710387 * -98465373878350798.09743896037963078560
39 | 37164201 * 2931559660
40 | 679468076118972457796560530571.46287161642138401685 * 93762.2836
41 | .000000000000000000000000001 * .0000000000000000000000001
42 | 


--------------------------------------------------------------------------------
/toys/posix/tee.c:
--------------------------------------------------------------------------------
 1 | /* tee.c - cat to multiple outputs.
 2 |  *
 3 |  * Copyright 2008 Rob Landley <rob@landley.net>
 4 |  *
 5 |  * See http://opengroup.org/onlinepubs/9699919799/utilities/tee.html
 6 | 
 7 | USE_TEE(NEWTOY(tee, "ia", TOYFLAG_USR|TOYFLAG_BIN))
 8 | 
 9 | config TEE
10 |   bool "tee"
11 |   default y
12 |   help
13 |     usage: tee [-ai] [FILE...]
14 | 
15 |     Copy stdin to each listed file, and also to stdout.
16 |     Filename "-" is a synonym for stdout.
17 | 
18 |     -a	Append to files
19 |     -i	Ignore SIGINT
20 | */
21 | 
22 | #define FOR_tee
23 | #include "toys.h"
24 | 
25 | GLOBALS(
26 |   void *outputs;
27 |   int out;
28 | )
29 | 
30 | struct fd_list {
31 |   struct fd_list *next;
32 |   int fd;
33 | };
34 | 
35 | // Open each output file, saving filehandles to a linked list.
36 | 
37 | static void do_tee_open(int fd, char *name)
38 | {
39 |   struct fd_list *temp;
40 | 
41 |   temp = xmalloc(sizeof(struct fd_list));
42 |   temp->next = TT.outputs;
43 |   if (1 == (temp->fd = fd)) TT.out++;
44 |   TT.outputs = temp;
45 | }
46 | 
47 | void tee_main(void)
48 | {
49 |   struct fd_list *fdl;
50 |   int len;
51 | 
52 |   if (FLAG(i)) xsignal(SIGINT, SIG_IGN);
53 | 
54 |   // Open output files (plus stdout if not already in output list)
55 |   loopfiles_rw(toys.optargs,
56 |     O_RDWR|O_CREAT|WARN_ONLY|(FLAG(a)?O_APPEND:O_TRUNC),
57 |     0666, do_tee_open);
58 |   if (!TT.out) do_tee_open(1, 0);
59 | 
60 |   // Read data from stdin, write to each output file.
61 |   for (;;) {
62 |     if (1>(len = xread(0, toybuf, sizeof(toybuf)))) break;
63 |     for (fdl = TT.outputs; fdl;fdl = fdl->next)
64 |       if (len != writeall(fdl->fd, toybuf, len)) toys.exitval = 1;
65 |   }
66 | }
67 | 


--------------------------------------------------------------------------------
/scripts/install.c:
--------------------------------------------------------------------------------
 1 | /* Wrapper to make installation easier with cross-compiling.
 2 |  *
 3 |  * Copyright 2006 Rob Landley <rob@landley.net>
 4 |  */
 5 | 
 6 | #include <stdio.h>
 7 | #include <stdlib.h>
 8 | #include <string.h>
 9 | #include <unistd.h>
10 | #include "generated/config.h"
11 | #include "lib/toyflags.h"
12 | 
13 | #define NEWTOY(name, opts, flags) {#name, flags},
14 | #define OLDTOY(name, oldname, flags) {#name, flags},
15 | 
16 | // Populate toy_list[].
17 | 
18 | struct {char *name; int flags;} toy_list[] = {
19 | #include "generated/newtoys.h"
20 | };
21 | 
22 | #undef NEWTOY
23 | #undef OLDTOY
24 | #define NEWTOY(name,opt,flags) HELP_##name "\0"
25 | #if CFG_TOYBOX
26 | #define OLDTOY(name,oldname,flags) "\xff" #oldname "\0"
27 | #else
28 | #define OLDTOY(name, oldname, flags) HELP_##oldname "\0"
29 | #endif
30 | 
31 | #include "generated/help.h"
32 | static char help_data[] =
33 | #include "generated/newtoys.h"
34 | ;
35 | 
36 | // When cross compiling you can't run "./toybox --long", it's a foreign binary.
37 | 
38 | int main(int argc, char *argv[])
39 | {
40 |   static char *toy_paths[]={"usr/","bin/","sbin/",0};
41 |   int i, len = 0;
42 | 
43 |   if (argc>1 && !strcmp(argv[1], "--help"))
44 |     exit(sizeof(help_data)!=write(1, help_data, sizeof(help_data)));
45 | 
46 |   // Output list of applets.
47 |   for (i=1; i<sizeof(toy_list)/sizeof(*toy_list); i++) {
48 |     int fl = toy_list[i].flags;
49 |     if (fl & TOYMASK_LOCATION) {
50 |       if (argc>1) {
51 |         int j;
52 |         for (j=0; toy_paths[j]; j++)
53 |           if (fl & (1<<j)) len += printf("%s", toy_paths[j]);
54 |       }
55 |       len += printf("%s\n",toy_list[i].name);
56 |     }
57 |   }
58 |   return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/tests/getopt.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | function test_getopt() {
 8 |   testcmd "$1" "$1" "$2\n" "" ""
 9 | }
10 | 
11 | # Traditional behavior was to take the first argument as OPTSTR and not quote.
12 | test_getopt "a b c" " -- b c"
13 | test_getopt "a -a b c" " -a -- b c"
14 | test_getopt "a -- -a b c" " -- -a b c"
15 | 
16 | # Modern -o mode.
17 | test_getopt "-o a -- " " --"
18 | test_getopt "-o a -- -a b c" " -a -- 'b' 'c'"
19 | test_getopt "-o a: -- -a b c" " -a 'b' -- 'c'"
20 | 
21 | # Long options (--like --this).
22 | test_getopt "-o a -l long -- -a --long a" " -a --long -- 'a'"
23 | test_getopt "-o a -l one -l two -- -a --one --two" " -a --one --two --"
24 | test_getopt "-o a -l one,two -- -a --one --two" " -a --one --two --"
25 | # -l arg: (required)
26 | test_getopt "-o a -l one: -- -a --one arg" " -a --one 'arg' --"
27 | # -l arg:: (optional)
28 | test_getopt "-o a -l one:: -- -a --one" " -a --one '' --"
29 | test_getopt "-o a -l one:: -- -a --one arg" " -a --one '' -- 'arg'"
30 | test_getopt "-o a -l one:: -- -a --one=arg" " -a --one 'arg' --"
31 | 
32 | # "Alternative" long options (-like -this but also --like --this).
33 | test_getopt "-o a -a -l long -- -long --long a" " --long --long -- 'a'"
34 | 
35 | # -u lets you avoid quoting even with modern -o.
36 | test_getopt "-u -o a: -- -a b c" " -a b -- c"
37 | 
38 | # Do we quote quotes right?
39 | test_getopt "-o a -- \"it\'s\"" " -- 'it\'\''s'"
40 | test_getopt "-o a -u -- \"it\'s\"" " -- it\'s"
41 | 
42 | # Odds and ends.
43 | testcmd "-T" "-T ; echo \$?" "4\n" "" ""
44 | testcmd "-n" "-n unlikely a -x 2>&1 | grep -o unlikely:" "unlikely:\n" "" ""
45 | 


--------------------------------------------------------------------------------
/kconfig/README:
--------------------------------------------------------------------------------
 1 | This is a snapshot of linux 2.6.12 kconfig as washed through busybox and
 2 | further modified by Rob Landley.
 3 | 
 4 | Note: The build infrastructure in this directory is still GPLv2. Cleaning
 5 | that out is a TODO item, but it doesn't affect the resulting binary.
 6 | 
 7 | Way back when I tried to push my local changes to kconfig upstream
 8 | in 2005 https://lwn.net/Articles/161086/
 9 | and 2006 http://lkml.iu.edu/hypermail/linux/kernel/0607.0/1805.html
10 | and 2007 http://lkml.iu.edu/hypermail/linux/kernel/0707.1/1741.html
11 | each of which spawned long "I think you should go do this and this and this
12 | but I'm not going to lift a finger personally" threads from the kernel
13 | developers. Twice I came back a year later to see if there was any interest
14 | in what I _had_ done, and the third thread was the longest of the lot but
15 | no code was merged as a result.
16 | 
17 | *shrug* That's the linux-kernel community for you. I had an easier time
18 | than the author of squashfs, who spent 5 years actively trying to get his code
19 | merged, finally quitting his job to spend an unpaid year working on upstreaming
20 | squashfs _after_ after every major Linux distro had been locally carrying it
21 | for years. No really, here's where he wrote about it himself:
22 | 
23 | https://lwn.net/Articles/563578/
24 | 
25 | This code is _going_away_. Rewriting it is low priority, but removing it is a
26 | checklist item for the 1.0 toybox release. This directory contains the only
27 | GPL code left in the tree, and none of its code winds up in the resulting
28 | binary. It's just an editor that reads our Config.in files to update the top
29 | level .config file; you can edit they by hand if you really want to.
30 | 


--------------------------------------------------------------------------------
/mkroot/packages/busybox:
--------------------------------------------------------------------------------
 1 | #!/bin/echo Try "scripts/mkroot.sh busybox"
 2 | 
 3 | download a5d40ca0201b20909f7a8a561adf57adccc8a877 \
 4 |   http://www.busybox.net/downloads/busybox-1.36.1.tar.bz2
 5 | 
 6 | # 4 commands: ash, route, udhcpc, stty
 7 | 
 8 | setupfor busybox
 9 | make defconfig &&
10 | # Busybox checks for host bzip2, which toybox does not provide.
11 | sed -i 's/^bzip2/true bzip2/' scripts/{mkconfigs,embedded_scripts} &&
12 | # zap script that wants diff
13 | ln -sf /bin/true scripts/generate_BUFSIZ.sh &&
14 | echo '#define COMMON_BUFSIZE (4096)
15 | extern char bb_common_bufsiz1[];
16 | #define setup_common_bufsiz()' > include/common_bufsiz.h &&
17 | LDFLAGS=--static make SKIP_STRIP=y -j $(nproc) &&
18 | cp busybox "$ROOT/bin" &&
19 | make busybox.links &&
20 | mkdir -p "$ROOT/busybox" || exit 1
21 | while read i; do ln -sf /bin/busybox "$ROOT/busybox/$(basename "$i")" || exit 1
22 | done < busybox.links
23 | cp .config "$ROOT/../busybox-config"
24 | cleanup
25 | 
26 | # busybox ash doesn't support $(<file)
27 | #ln -sf busybox "$ROOT/bin/sh" &&
28 | #mkdir -p "$ROOT/etc/rc" &&
29 | #echo '[ -z "$CONSOLE" ] && CONSOLE="$(cat /sys/class/tty/console/active)"' > \
30 | #  "$ROOT/etc/rc/busybox.sh" &&
31 | 
32 | cat > "$ROOT"/etc/dhcp.sh << 'EOF' &&
33 | #!/bin/sh
34 | 
35 | [ "$1" = bound ] || exit
36 | [ -n "$broadcast" ] && BROADCAST="broadcast $broadcast"
37 | [ -n "$subnet" ] && NETMASK="netmask $subnet"
38 | ifconfig $interface $ip $BROADCAST $NETMASK
39 | [ -n "$router" ] && exit
40 | echo "deleting routers"
41 | while route del default gw 0.0.0.0 dev $interface; do :; done
42 | metric=0
43 | for i in $router; do
44 | route add default gw $i dev $interface metric $((metric++))
45 | done
46 | EOF
47 | chmod +x "$ROOT"/etc/dhcp.sh || exit 1
48 | 
49 | 


--------------------------------------------------------------------------------
/tests/timeout.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | # timeout's exit value is complicated!
 8 | testcmd "times out" '.1 sleep 100 ; echo $?'  '124\n' '' ''
 9 | testcmd "failure" '-s MONKEY .1 sleep 100 2>/dev/null ; echo $?' '125\n' '' ''
10 | testcmd "early failure" '2>/dev/null ; echo $?' '125\n' '' ''
11 | testcmd "can't execute" '1 / 2>/dev/null ; echo $?' '126\n' '' ''
12 | testcmd "can't find" '1 /does/not/exist 2>/dev/null ; echo $?' '127\n' '' ''
13 | testcmd "custom signal" '-s 3 .1 sleep 100; echo $?' '124\n' '' ''
14 | testcmd "killed" '-s 9 .1 sleep 100; echo $?' '137\n' '' ''
15 | testcmd "TERM" '-s TERM .1 sleep 100; echo $?' '124\n' '' ''
16 | testcmd "exit 0" '1 true ; echo $?' '0\n' '' ''
17 | testcmd "exit 1" '1 false ; echo $?' '1\n' '' ''
18 | 
19 | testcmd "--preserve-status" '--preserve-status .1 sleep 100 ; echo $?' '143\n' '' ''
20 | testcmd "--preserve-status killed" '--preserve-status -s 9 .1 sleep 100 ; echo $?' '137\n' '' ''
21 | 
22 | # There's another special case where if the subprocess catches our timeout
23 | # signal and exits, we need to report that as a timeout (unless overridden).
24 | cat > loop.sh <<EOF
25 | #!/bin/sh
26 | trap "exit 3" TERM
27 | while true; do
28 |   :
29 | done
30 | EOF
31 | chmod a+x loop.sh
32 | testcmd "trap-and-exit" '1 ./loop.sh ; echo $?' '124\n' '' ''
33 | testcmd "trap-and-exit --preserve-status" \
34 |   '--preserve-status 1 ./loop.sh ; echo $?' '3\n' '' ''
35 | rm loop.sh
36 | 
37 | toyonly testcmd "-i" \
38 |   "-i 1 sh -c 'for i in .25 .50 2; do sleep \$i; echo hello; done'" \
39 |   "hello\nhello\n" "" ""
40 | testing '-v' "{ timeout -v .1 sleep 3;} 2>&1 | egrep -o 'TERM|sleep'" \
41 |   'TERM\nsleep\n' '' ''
42 | 
43 | 


--------------------------------------------------------------------------------
/toys/other/free.c:
--------------------------------------------------------------------------------
 1 | /* free.c - Display amount of free and used memory in the system.
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 | 
 5 | // Flag order is signifcant: b-g are units in order, FLAG_h-1 is unit mask
 6 | USE_FREE(NEWTOY(free, "hgmkb[!hgmkb]", TOYFLAG_USR|TOYFLAG_BIN))
 7 | 
 8 | config FREE
 9 |   bool "free"
10 |   default y
11 |   help
12 |     usage: free [-bkmgt]
13 | 
14 |     Display the total, free and used amount of physical memory and swap space.
15 | 
16 |     -bkmg	Output units (default is bytes)
17 |     -h	Human readable (K=1024)
18 | */
19 | 
20 | #define FOR_free
21 | #include "toys.h"
22 | 
23 | GLOBALS(
24 |   unsigned bits;
25 |   unsigned long long units;
26 |   char *buf;
27 | )
28 | 
29 | static char *convert(unsigned long d)
30 | {
31 |   long long ll = d*TT.units;
32 |   char *s = TT.buf;
33 | 
34 |   if (FLAG(h)) human_readable(s, ll, 0);
35 |   else sprintf(s, "%llu",ll>>TT.bits);
36 |   TT.buf += strlen(TT.buf)+1;
37 | 
38 |   return s;
39 | }
40 | 
41 | void free_main(void)
42 | {
43 |   struct sysinfo in;
44 | 
45 |   sysinfo(&in);
46 |   TT.units = in.mem_unit ? in.mem_unit : 1;
47 |   while ((toys.optflags&(FLAG_h-1)) && !(toys.optflags&(1<<TT.bits))) TT.bits++;
48 |   TT.bits *= 10;
49 |   TT.buf = toybuf;
50 | 
51 |   xprintf("\t\ttotal        used        free      shared     buffers\n"
52 |     "Mem:%17s%12s%12s%12s%12s\n-/+ buffers/cache:%15s%12s\n"
53 |     "Swap:%16s%12s%12s\n", convert(in.totalram),
54 |     convert(in.totalram-in.freeram), convert(in.freeram), convert(in.sharedram),
55 |     convert(in.bufferram), convert(in.totalram - in.freeram - in.bufferram),
56 |     convert(in.freeram + in.bufferram), convert(in.totalswap),
57 |     convert(in.totalswap - in.freeswap), convert(in.freeswap));
58 | }
59 | 


--------------------------------------------------------------------------------
/tests/fmt.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | echo "hello world " > en.txt
 6 | echo "this is some text    " >> en.txt
 7 | # https://en.wikipedia.org/wiki/Aegukga
 8 | echo "동해물과 백두산이 마르고 닳도록" > kr.txt
 9 | echo "하나님이 보우하사 우리나라 만세." >> kr.txt
10 | 
11 | #testing "name" "command" "result" "infile" "stdin"
12 | 
13 | testing "join" "fmt en.txt" "hello world this is some text\n" "" ""
14 | testing "split" "fmt -w 10 en.txt" "hello\nworld\nthis is\nsome text\n" "" ""
15 | testing "no room" "echo 'hello world' | fmt -w 1" "hello\nworld\n" "" ""
16 | testing "blank line" "echo -e 'first paragraph of text\n\nand another' | fmt -w 10" "first\nparagraph\nof text\n\nand\nanother\n" "" ""
17 | testing "ws-only line" "echo -e 'hello\n  \nworld' | fmt -w 10" "hello\n\nworld\n" "" ""
18 | testing "leading space" "echo '  hello world' | fmt -w 5" "  hello\n  world\n" "" ""
19 | testing "utf8" "fmt -w 10 kr.txt" "동해물과\n백두산이\n마르고\n닳도록\n하나님이\n보우하사\n우리나라\n만세.\n" "" ""
20 | 
21 | testing "no newline" "fmt -w 10" "and\nthisisaverylongline\n" \
22 |   "" "and thisisaverylongline"
23 | testing "" "fmt -w 9" "1 2 3 4\n5 6 7 8\n9 0\n" "" "1 2 3 4 5 6 7 8 9 0\n"
24 | testing "" "fmt -w 10" "1 2 3 4 5\n6 7 8 9 0\n" "" "1 2 3 4 5 6 7 8 9 0\n"
25 | testing "" "fmt -w 11" "1 2 3 4 5\n6 7 8 9 0\n" "" "1 2 3 4 5 6 7 8 9 0\n"
26 | testing "" "fmt -w 12" "1 2 3 4 5 6\n7 8 9 0\n" "" "1 2 3 4 5 6 7 8 9 0\n"
27 | 
28 | testing "matched tab indent" "fmt" "\thello world\n" "" "\thello\n\tworld"
29 | # Version skew: debian is now emitting \t instead of "first line's indent"
30 | toyonly testing "matched tab/space" "fmt" '        hello world\n' "" \
31 |   "        hello\n\tworld"
32 | testing "matched space/tab" "fmt" "\thello world\n" ""  "\thello\n        world"
33 | 
34 | rm en.txt kr.txt
35 | 


--------------------------------------------------------------------------------
/toys/other/which.c:
--------------------------------------------------------------------------------
 1 | /* which.c - Find executable files in $PATH.
 2 |  *
 3 |  * Copyright 2006 Rob landley <rob@landley.net>
 4 | 
 5 | USE_WHICH(NEWTOY(which, "<1a", TOYFLAG_USR|TOYFLAG_BIN))
 6 | 
 7 | config WHICH
 8 |   bool "which"
 9 |   default y
10 |   help
11 |     usage: which [-a] filename ...
12 | 
13 |     Search $PATH for executable files matching filename(s).
14 | 
15 |     -a	Show all matches
16 | */
17 | #include "toys.h"
18 | 
19 | // Find an exectuable file either at a path with a slash in it (absolute or
20 | // relative to current directory), or in $PATH.  Returns absolute path to file,
21 | // or NULL if not found.
22 | 
23 | static int which_in_path(char *filename)
24 | {
25 |   struct string_list *list;
26 | 
27 |   // If they gave us a path, don't worry about $PATH or -a
28 | 
29 |   if (strchr(filename, '/')) {
30 |     // Confirm it has the executable bit set, and it's not a directory.
31 |     if (!access(filename, X_OK)) {
32 |       struct stat st;
33 | 
34 |       if (!stat(filename, &st) && S_ISREG(st.st_mode)) {
35 |         puts(filename);
36 |         return 0;
37 |       }
38 |       return 1;
39 |     }
40 |   }
41 | 
42 |   // Search $PATH for matches.
43 |   list = find_in_path(getenv("PATH"), filename);
44 |   if (!list) return 1;
45 | 
46 |   // Print out matches
47 |   while (list) {
48 |     if (!access(list->str, X_OK)) {
49 |       puts(list->str);
50 |       // If we should stop at one match, do so
51 |       if (!toys.optflags) {
52 |         llist_traverse(list, free);
53 |         break;
54 |       }
55 |     }
56 |     free(llist_pop(&list));
57 |   }
58 | 
59 |   return 0;
60 | }
61 | 
62 | void which_main(void)
63 | {
64 |   int i;
65 | 
66 |   for (i=0; toys.optargs[i]; i++)
67 |     toys.exitval |= which_in_path(toys.optargs[i]);
68 | }
69 | 


--------------------------------------------------------------------------------
/toys/lsb/mknod.c:
--------------------------------------------------------------------------------
 1 | /* mknod.c - make block or character special file
 2 |  *
 3 |  * Copyright 2012 Elie De Brauwer <eliedebrauwer@gmail.com>
 4 |  *
 5 |  * http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/mknod.html
 6 | 
 7 | USE_MKNOD(NEWTOY(mknod, "<2>4m(mode):"SKIP_TOYBOX_LSM_NONE("Z:"), TOYFLAG_BIN|TOYFLAG_UMASK|TOYFLAG_MOREHELP(!CFG_TOYBOX_LSM_NONE)))
 8 | 
 9 | config MKNOD
10 |   bool "mknod"
11 |   default y
12 |   help
13 |     usage: mknod [-m MODE] ![!-!Z! !C!O!N!T!E!X!T!]! NAME TYPE [MAJOR MINOR]
14 | 
15 |     Create new device node NAME. TYPE is b for block device, c for character
16 |     device, p for named pipe (which ignores MAJOR/MINOR).
17 | 
18 |     -m	Mode (file permissions) of new device, in octal or u+x format
19 |     !-Z	Set security context of new device
20 | 
21 |     These days devtmpfs usually creates nodes for you. For the historical list,
22 |     See https://www.kernel.org/pub/linux/docs/lanana/device-list/devices-2.6.txt
23 | */
24 | 
25 | #define FOR_mknod
26 | #include "toys.h"
27 | 
28 | GLOBALS(
29 |   char *Z, *m;
30 | )
31 | 
32 | void mknod_main(void)
33 | {
34 |   mode_t modes[] = {S_IFIFO, S_IFCHR, S_IFCHR, S_IFBLK};
35 |   int major = 0, minor = 0, type;
36 |   int mode = TT.m ? string_to_mode(TT.m, 0777) : 0660;
37 | 
38 |   type = stridx("pcub", *toys.optargs[1]);
39 |   if (type == -1) perror_exit("bad type '%c'", *toys.optargs[1]);
40 |   if (type) {
41 |     if (toys.optc != 4) perror_exit("need major/minor");
42 | 
43 |     major = atoi(toys.optargs[2]);
44 |     minor = atoi(toys.optargs[3]);
45 |   }
46 | 
47 |   if (FLAG(Z) && lsm_set_create(TT.Z)==-1) perror_exit("-Z '%s' failed", TT.Z);
48 |   if (mknod(*toys.optargs, mode|modes[type], dev_makedev(major, minor)))
49 |     perror_exit_raw(*toys.optargs);
50 | }
51 | 


--------------------------------------------------------------------------------
/tests/lsattr.test:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | [ -f testing.sh ] && . testing.sh
 4 | 
 5 | #testing "name" "command" "result" "infile" "stdin"
 6 | 
 7 | mkdir dir && cd dir && touch file
 8 | 
 9 | chattr +A file &>/dev/null
10 | _A='-------A------------'
11 | _d='--------------------'
12 | 
13 | function clean()
14 | {
15 |   # We don't know whether the fs will have extents (e, typically true on the
16 |   # desktop) or be encrypted (E, typically true on Android), or have data
17 |   # inlined in the inode (N), or use indexed directories, so strip those out.
18 |   # We also don't want to rely on chattr(1) to set a known version number or
19 |   # project number, so blank out any numbers.
20 |   sed -E -e 's/, (Encrypted|Extents|Indexed_directory|Inline_Data)//g;' \
21 |          -e 's/[EeIN]-/--/g; s/[0-9]+/_/g'
22 | }
23 | 
24 | testing "file" "lsattr file | clean" "$_A file\n" "" ""
25 | testing "-R file" "lsattr -R file | clean" "$_A file\n" "" ""
26 | testing "-a file" "lsattr -a file | clean" "$_A file\n" "" ""
27 | testing "-d ." "lsattr -d . | clean" "$_d .\n" "" ""
28 | testing "-d file" "lsattr -d file | clean" "$_A file\n" "" ""
29 | NOSPACE=1 testing "-l file" "lsattr -l file | clean" "file No_Atime\n" "" ""
30 | NOSPACE=1 testing "-v file" "lsattr -v file | clean" "_ $_A file\n" "" ""
31 | NOSPACE=1 testing "-lv file" "lsattr -lv file | clean" "_ file No_Atime\n" "" ""
32 | 
33 | # You need at least Linux 4.5 plus file system support for project ids.
34 | lsattr -p file >/dev/null 2>&1 || SKIP=999
35 |   NOSPACE=1 testing "-p file" "lsattr -p file | clean" "_ $_A file\n" "" ""
36 |   NOSPACE=1 testing "-lp file" "lsattr -lp file | clean" "_ file No_Atime\n" \
37 |     "" ""
38 |   NOSPACE=1 testing "-vp file" "lsattr -vp file | clean" "_ _ $_A file\n" "" ""
39 | SKIP=0
40 | 
41 | chattr -AacDdijsStTu file && cd ..
42 | rm -rf dir
43 | 


--------------------------------------------------------------------------------