Compare commits

...
146 Commits
Author SHA1 Message Date
Erik Andersen 83865e3e90 Ready for release 2000-01-15 22:33:09 +00:00
Erik Andersen 3163821967 Sync up busybox with the latest and greatest. This is not stuff for
the Embedix release.
 -Erik
2000-01-15 22:28:50 +00:00
Erik Andersen b7cc49d992 * Added -o loop option for mount, and support in umount for loop
devices. Support is toggled by MOUNT_LOOP feature -- Ben Collins
    <bcollins@debian.org>

 -Erik
2000-01-13 06:38:14 +00:00
Erik Andersen 05df239ed9 Bug fixes.
-Erik
2000-01-13 04:43:48 +00:00
Erik Andersen 9a9a261569 Fix a logger bug.
-Erik
2000-01-09 06:49:08 +00:00
Erik Andersen ac6e71f0c4 Possible fixes...
-Erik
2000-01-08 22:04:33 +00:00
Erik Andersen 766f9c7a19 Oops. left debug on.
-Erik
2000-01-08 21:20:49 +00:00
Erik Andersen 1dbc17f630 Fix cp and mv so 'cp foo/README bar' where foo and bar are directories,
and README is a file.
 -Erik
2000-01-08 21:16:29 +00:00
Erik Andersen 5338ce19c8 foo 2000-01-07 23:30:07 +00:00
Erik Andersen 5f2df6ccb4 Remove some leftover debug noise.
-Erik
2000-01-07 23:11:00 +00:00
Erik Andersen 9b5c0b7611 More adjustments
-Erik
2000-01-07 18:33:06 +00:00
Erik Andersen 812d46667d More minor fixes.
-Erik
2000-01-07 18:30:40 +00:00
Erik Andersen 96e2abd084 Init is now even more perfect then before.
-Erik
2000-01-07 11:40:44 +00:00
Erik Andersen 286b0de74d Trivial type fix.
-Erik
2000-01-07 09:43:38 +00:00
Erik Andersen d38eaef70b foo 2000-01-07 02:55:55 +00:00
Erik Andersen 0e3782f7c3 Init is now _more_ perfect then before.
-Erik
2000-01-07 02:54:55 +00:00
John Beppu 9324b400ab making note of my changes. 2000-01-07 02:04:58 +00:00
John Beppu 9d83165d9e added uniq_usage message 2000-01-07 01:57:32 +00:00
John Beppu 96f1f33e56 did tedious stuff 2000-01-06 23:49:21 +00:00
Erik Andersen 3695052813 Add in sample inittab file
-Erik
2000-01-06 01:16:59 +00:00
Erik Andersen 9e7372584f inittab is now perfect. The universe will now submit to my
will. muhahahaha!!!  Phear!
 -Erik
2000-01-06 01:16:13 +00:00
Erik Andersen 0b874ed41f Cool. Beppu is doing uniq.
-Erik
2000-01-06 01:14:56 +00:00
John Beppu abb4772b28 i am busybox of borg. unix will be assimilated. 2000-01-06 00:48:21 +00:00
Erik Andersen 0881de706e The latest and greatest. init basically works, though needs
a minor inittab design change to accomodate specifying the device
to run each process on.
 -Erik
2000-01-05 09:34:26 +00:00
Erik Andersen f4a99cc02c heheh. Forgot the fix. Here it is:
* Grep -i previously failed on UPPER CASE patterns due to a silly
    regexp implementation bug that is now fixed.

 -Erik
2000-01-05 05:49:51 +00:00
Erik Andersen fb62e3225f * Grep -i previously failed on UPPER CASE patterns due to a silly
regexp implementation bug that is now fixed.

 -Erik
2000-01-05 05:47:11 +00:00
Erik Andersen 7dc160721e Bunches of fixes. Typos, bugs, etc.
Added 'gunzip -t'.  inittab support _almost_ works (but it isn't
ready for prime time useage yet).
 -Erik
2000-01-04 01:10:25 +00:00
Erik Andersen 9c88cac5cb First pass inittab parser written
-Erik
1999-12-30 09:25:17 +00:00
Erik Andersen 1266a13e1f * sed now supports addresses (numeric or regexp, with negation) and
has an append command, thanks to Marco Pantaleoni <panta@prosa.it>
* Fixed dmesg.  It wasn't parsing its options (-n or -s) properly.
* Some cosmetic fixes to ls output formatting to make it behave more
    like GNU ls.
 -Erik
1999-12-29 22:19:46 +00:00
Erik Andersen a89910829c Add the beginings of some regression testing. Add in the recently
contributed loadacm utility (for dealing with unicode fonts)
 -Erik
1999-12-29 03:34:00 +00:00
Erik Andersen f664c004db Fixed mv so it now does the right thing (same method used in cp). Removed
some cruft from cp.
 -Erik
1999-12-29 02:36:29 +00:00
Erik Andersen 2fe08c7afb Fixed cp so it works as God intended it to.
-Erik
1999-12-29 02:10:35 +00:00
Erik Andersen 00266d3df6 Fixed a bug where tar would not set the user and group on device
special files.
 -Erik
1999-12-28 00:17:46 +00:00
Erik Andersen 69ba6b2956 Added changelog
-Erik
1999-12-27 23:56:17 +00:00
Erik Andersen 98f67e35d8 chown(2) clears S_ISUID and S_ISGID, even when chown is
called as root.  Changed ordering of chown and chmod so
SGID and SUID file permissions don't get munged.
 -Erik
1999-12-27 23:48:33 +00:00
John Beppu 00417a38c1 sort is good to go. 1999-12-23 22:46:10 +00:00
John Beppu ee512a3f86 implemented numeric sort (sort -g) 1999-12-23 00:02:49 +00:00
John Beppu 568cb7b45f oops.. qsort(2) misunderstanding on my part.
it's ok, now.
1999-12-22 23:02:12 +00:00
John Beppu d19385e160 playing w/ $Log$ 1999-12-22 22:27:01 +00:00
John Beppu f3e59041b5 the base is nearly done.
need to implement various comparison functions, now.
1999-12-22 22:24:52 +00:00
John Beppu 019513a59f added hooks for sort 1999-12-22 17:57:31 +00:00
John Beppu 38efa7902e work in progress... 1999-12-22 00:30:29 +00:00
John Beppu c0ca473af9 this is my work in progress. 1999-12-21 20:00:35 +00:00
Erik Andersen 3fe2ecf0d9 Added grep -q, thanks to a patch from "Konstantin Boldyshev" <konst@voshod.com>
-Erik
1999-12-21 08:52:04 +00:00
Erik Andersen d387d01f11 Sync to my local tree 1999-12-21 02:55:11 +00:00
Erik Andersen f294a0288d Fix double quoting bug preventing ininit scripts from running 1999-12-21 02:54:37 +00:00
Erik Andersen 021043205c Add in first draft of insmod. Not yet working (but will Real Soon Now(tm))
-Erik
1999-12-17 18:57:34 +00:00
Erik Andersen 10c341af35 Make head --version do the right thing. Update TODO list
-Erik
1999-12-17 18:52:06 +00:00
Erik Andersen 4d1d0113fd Reworked the source so it will compile and run under glibc 2.0.7
and linux kernel 2.0.36 (though the dubious reasons why someone
would want to do that defy imagination ;)
 -Erik
1999-12-17 18:44:15 +00:00
Erik Andersen 6da0ae8183 Minor fixes to rmmod. First pass at insmod (not yet working).
-Erik
1999-12-17 01:08:27 +00:00
Mark Whitley c144e330c0 Fixed correctness of comment in rmmod.c - MKW 1999-12-17 00:01:46 +00:00
Erik Andersen 2129b146db Added an AUTHORS file to acknowledge the folks that have
done stuff.
 -Erik
1999-12-16 23:26:57 +00:00
Erik Andersen 3d7e3414da Wrote rmmod for busybox.
-Erik
1999-12-16 23:04:20 +00:00
John Beppu 0aa6118167 killed an elusive bug in du -s. 1999-12-16 21:16:47 +00:00
Erik Andersen 1c5b2589d1 Fix bugs in logger and syslogd. Add fbset.
-Erik
1999-12-16 20:59:36 +00:00
Erik Andersen 6f23cec5d0 Added lsmod
-Erik
1999-12-15 22:14:12 +00:00
John Beppu 935fb3886f made note of my recent changes 1999-12-15 19:35:02 +00:00
John Beppu 25ab653457 fixed an embarrasing segfault (head w/ no args
used to die (but now it lives))
1999-12-15 19:29:09 +00:00
John Beppu e1618e42a8 Implemented du -s 1999-12-15 18:52:17 +00:00
Erik Andersen 3cd5d2541f Turn off loadkmap and loadfont. We won't be needing those.
-Erik
1999-12-15 08:20:08 +00:00
Eric Andersen 0f0fcecf7f Added the list of available commands.
-Erik
1999-12-12 05:32:52 +00:00
Eric Andersen 664584b50e Fixed spelling of my name. Geez.
Ah kant evun spel mi nam.
 -Erik
1999-12-11 23:25:59 +00:00
Eric Andersen 19db07b3d4 Ok, so this is reallt 0.38...
-Erik
1999-12-11 08:41:28 +00:00
Eric Andersen 59248bad97 Set version to 0.39
-Erik
1999-12-11 04:21:50 +00:00
Eric Andersen 84b009256f Minor updates 1999-12-11 04:16:51 +00:00
John Beppu b52a218c95 Removed a redundant call du(); Save cpu cycles. 1999-12-10 15:23:47 +00:00
John Beppu 59017e80da damnit.
removed mkfifo from the TODO list.

    I didn't implement it, because I realized (too late) that
    mknod already existed, and it can do anything that mkfifo
    would have done.
1999-12-10 08:44:54 +00:00
Eric Andersen cf53687376 Fixed John's email address again.
John.  Your email address is "john@lineo.com" not @line.com. :)
 -Erik
1999-12-10 08:29:20 +00:00
Eric Andersen 2cb55077e2 Added poweroff (and adjusted init to use it). Inlined function
calls to code only called once in tee.  Made BB_KLOGD and option.
 -Erik
1999-12-10 08:25:07 +00:00
John Beppu c5ff0165ad less TODO 1999-12-10 07:48:34 +00:00
John Beppu 3157b1fba9 Implemented head(1).
tried to mimic GNU behaviour.
1999-12-10 07:42:50 +00:00
John Beppu a3e0d7928b changed tee_usage from being a function to a char[]
that gets used be usage();
1999-12-10 07:41:03 +00:00
John Beppu 9835541c54 Fixed bug when dealing with files specified
on the command line that didn't exist.
1999-12-10 07:40:08 +00:00
Eric Andersen 21818c8a80 Make sure the world knows who "beppu" is.
-Erik
1999-12-10 06:48:10 +00:00
Eric Andersen 70e2f0b111 Fix beppu's email address.
BTW, John, go to sleep.  It is late. :)
 -Erik
1999-12-10 06:45:42 +00:00
John Beppu 14c82b64c9 Fleshed out du_main().
I'm not sure which options to support.
1999-12-10 06:15:27 +00:00
John Beppu 2ad2afd05c less TODO 1999-12-10 06:14:28 +00:00
John Beppu 059f152a7a Implemented tee(1). 1999-12-10 05:27:16 +00:00
John Beppu 29fcc90f3e minor changelog update 1999-12-09 23:33:04 +00:00
Eric Andersen 6805d5d69e Adjustments for Johns init stuff,
-Erik
1999-12-09 22:39:55 +00:00
John Beppu f95ca97d1b findInitPid() has been implemented and it seems to work.
reboot has been changed to take advantage of findInitPid();
1999-12-09 22:10:18 +00:00
John Beppu 395b216a2e du is done 1999-12-09 18:37:56 +00:00
John Beppu 7a98606d85 Modified to include du 1999-12-09 18:29:29 +00:00
John Beppu 0f5e1ab949 This is my preliminary
du implementation.  It
    was written from scratch
    (doesn't use recursiveAction).
    I still need to flesh out
    du_main().
1999-12-09 18:23:54 +00:00
Eric Andersen f0758dd6ba * Fixed rebooting from init. I'd left some debugging code in
which blocked reboots.  Oops.
 -Erik
1999-12-09 07:57:58 +00:00
Eric Andersen 1792f8c489 Tail now works (costs 6k). Several other updates.
-Erik
1999-12-09 06:11:36 +00:00
Eric Andersen c24db7b591 Added an empty line for no reason.
-Erik
1999-12-09 01:29:12 +00:00
Eric Andersen 8cd6a1f9a2 Fixed spelling error
-Erik
1999-12-09 01:26:38 +00:00
Eric Andersen 48091fb3d3 * my_getid was leaking file descriptors, causing 'ls -l' on long
directories to fail
 -Erik
1999-12-09 01:15:52 +00:00
Eric Andersen abc0f4f8f9 Latest and greatest 1999-12-08 23:19:36 +00:00
Eric Andersen 2285f367e2 Stuf 1999-12-08 04:23:30 +00:00
Eric Andersen fcdb57a0fc Fixes 1999-12-08 04:13:59 +00:00
Eric Andersen d29edf34d6 Stuf 1999-12-08 04:13:44 +00:00
Eric Andersen 485b9550fd Stuf 1999-12-07 23:14:59 +00:00
Eric Andersen d00c262847 Stuf 1999-12-07 08:37:31 +00:00
Eric Andersen 0ecb54a0f3 Stuf 1999-12-05 23:24:55 +00:00
Eric Andersen 14ec6cf3c2 syslogd and klogd work now.
-Erik
1999-12-05 22:17:02 +00:00
Eric Andersen de1d61268e Fixes 1999-12-03 15:14:25 +00:00
Eric Andersen b186d980d6 Stuf 1999-12-03 09:19:54 +00:00
Eric Andersen 77619b9dda Sqtuf 1999-11-29 04:31:50 +00:00
Eric Andersen bb58702833 Fix up changelog 1999-11-29 04:30:12 +00:00
Eric Andersen 03018f7551 Fixed tar so uid/gud/permissions on extracted tarballs will be correct.
-Erik
1999-11-29 04:29:13 +00:00
Eric Andersen 1667fb4b63 Fixes 1999-11-27 20:34:28 +00:00
Eric Andersen c054b21f7d Stuf 1999-11-27 17:41:29 +00:00
Eric Andersen 4c78147755 Changes 1999-11-26 08:12:56 +00:00
Eric Andersen ec33d45e89 Stuf 1999-11-26 01:51:02 +00:00
Eric Andersen befda6e4ed Stuf 1999-11-25 08:06:22 +00:00
Eric Andersen 3843e96252 Stuf 1999-11-25 07:30:46 +00:00
Eric Andersen b99df0fd65 First draft 1999-11-24 09:04:33 +00:00
Eric Andersen 394f764e7d Stuf 1999-11-23 21:38:12 +00:00
Eric Andersen cb41c2e83b Bug fixes 1999-11-22 07:41:00 +00:00
Eric Andersen 5d44d1fda5 Stuf 1999-11-22 06:01:01 +00:00
Eric Andersen 0f4c0848c7 Fix bugs 1999-11-22 05:57:09 +00:00
Eric Andersen 0727458a97 Stuf 1999-11-21 21:50:07 +00:00
Eric Andersen fa213cd71e Latest n greatest 1999-11-19 06:24:35 +00:00
Eric Andersen e1850ddde4 Stuf 1999-11-19 05:42:32 +00:00
Eric Andersen 6a76e652aa Stuf 1999-11-19 05:31:45 +00:00
Eric Andersen 08b1034f4f Stuf 1999-11-19 02:38:58 +00:00
Eric Andersen ab746abfc0 Stuf 1999-11-18 20:33:45 +00:00
Eric Andersen 1c43d0c5af Stuff 1999-11-18 07:58:07 +00:00
Eric Andersen b052b47722 Forgot this. 1999-11-18 00:21:59 +00:00
Eric Andersen ded6259f62 Latest and greatest 1999-11-18 00:19:26 +00:00
Eric Andersen d80e851dc0 Stuf 1999-11-16 00:46:00 +00:00
Eric Andersen a9c95ea655 Updates 1999-11-15 17:33:30 +00:00
Eric Andersen 80974fad03 Fix makefile 1999-11-13 04:51:47 +00:00
Eric Andersen b6a44b8d39 updates for the day 1999-11-13 04:47:09 +00:00
Eric Andersen eded54bd96 Adjust install a bit... 1999-11-12 08:03:23 +00:00
Eric Andersen 96bcfd346b Latest and greatest
-Erik
1999-11-12 01:30:18 +00:00
Eric Andersen 0dfac6b9ce Stuff 1999-11-11 05:46:32 +00:00
Eric Andersen c296b54827 Stuf 1999-11-11 01:36:55 +00:00
Eric Andersen d73dc5b073 Updates to usage, and made tar work.
-Erik
1999-11-10 23:13:02 +00:00
Eric Andersen 84d8568071 spelling fixes 1999-11-10 20:17:47 +00:00
Eric Andersen 5556c1874b Maybe works now...
-Erik
1999-11-10 19:27:58 +00:00
Eric Andersen 3e2bb288da Stuf 1999-11-09 03:12:29 +00:00
Eric Andersen add0158554 LAtest and greatest 1999-11-09 03:10:26 +00:00
Eric Andersen 3d8dbe1ca0 Stuf 1999-11-09 01:51:02 +00:00
Eric Andersen 50d6360771 Stuff 1999-11-09 01:47:36 +00:00
Eric Andersen fbb39c83b6 Stuff
-Erik
1999-11-08 17:00:52 +00:00
Eric Andersen 07e5297ca7 init and ls -l fixes 1999-11-07 07:38:08 +00:00
Eric Andersen dc6301e7ca Stuf 1999-11-06 07:34:50 +00:00
Eric Andersen 350577c5a0 Minor stuf 1999-11-06 06:34:20 +00:00
Eric Andersen 29d2e362de Fixed ln, df, and removed redundant stuff from mtab. 1999-11-06 06:07:27 +00:00
Eric Andersen bc34190694 Forgot this file... 1999-11-06 04:56:00 +00:00
Eric Andersen f14937d177 Update 1999-11-06 03:02:42 +00:00
Eric Andersen e18c75a563 Fixed init so it won't hang on reboot... 1999-11-05 04:23:05 +00:00
Eric Andersen 9997685953 Changelog fix 1999-11-05 01:21:49 +00:00
155 changed files with 21353 additions and 2055 deletions

No files matched your search

+40
View File
@@ -0,0 +1,40 @@
List of the authors of code contained in busybox.
If you should be listed here, or the description of
what you have done needs more detail, or is incorect,
_please_ let me know.
-Erik
-----------
Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
Tons of new stuff, major rewrite of most of the
core apps, tons of new apps as noted in header files.
Bruce Perens <bruce@pixar.com>
Original author of BusyBox. His code is still in many apps.
John Beppu <beppu@lineo.com>
du, head, tee
Brian Candler <B.Candler@pobox.com>
tiny-ls(ls)
Randolph Chung <tausq@debian.org>
fbset, ping, hostname, and mkfifo
Dave Cinege <dcinege@psychosis.com>
more(v2), makedevs, dutmp, modularization, auto links file,
various fixes, Linux Router Project maintenance
Linus Torvalds <torvalds@transmeta.com>
mkswap, fsck.minix, mkfs.minix
Charles P. Wright <cpwright@villagenet.com>
gzip, mini-netcat(nc)
Enrique Zanardi <ezanardi@ull.es>
tarcat (since removed), loadkmap, various fixes, Debian maintenance
+234 -4
View File
@@ -1,5 +1,231 @@
0.41
* New Apps: wc, hostid, logname, tty, whoami, yes -- all contributed
by Edward Betts <edward@debian.org>
* Fixed a bug in both cp and mv preventing 'cp foo/README bar'
type commands (file in a directory to another directory)
from working.
* Fixed a logger bug that caused garbage to be written to the syslog
(unless you used busybox syslog, which hid the bug). Thanks
to Alex Holden <alex@linuxhacker.org> for the fix.
* /bin/true and /bin/false were echoing a blank line when run. Now fixed.
* mkdir -p would print an error when asked to mkdir an existing dir
with no interveining subdirectories.
* Fixed "syslogd -O" so that it works.
* Added -o loop option for mount, and support in umount for loop
devices. Support is toggled by MOUNT_LOOP feature -- Ben Collins
<bcollins@debian.org>
* Several fixes from Marco Pantaleoni <panta@prosa.it>
* compile in fullWrite() not only if BB_TAR is defined, but also
if BB_CP or BB_MV are (fullWrite() is referenced by copyFile())
* add some compiler optimizations to further reduce executable size
(as a side note, on my machines the largest code is generated by
gcc 2.95.2 with -Os ! The smallest by plain gcc 2.7.2.3 with -O2
-m386 ...)
* Compile no longer fails if busybox.def.h defines BB_FEATURE_LINUXRC
but not BB_INIT. (init_main used to be referenced, but not compiled)
* Fixed a bug in setting TERM for serial console support. TERM now
defaults to "ansi" for serial consoles.
* Fixed a bug in handling the CONSOLE env. variable for serial consoles.
-Erik Andersen, Jan 15, 2000
0.40
* New Apps: sort, uniq. -beppu
* New Apps: lsmod, rmmod -erik
* New Apps: fbset contributed by Randolph Chung <tausq@debian.org>.
* New App:: loadacm contributed by Peter Novodvorsky <petya@logic.ru>
for loading application character maps for Unicode fonts.
* Major init re-work. init now supports inittab (slightly different
but similar to sysvinit), allowing me to get all the policy out
of init and into the conf file. It works just fine without inittab
being present, but if you dont like the defautl behavior you can
now do something about it. Init is much cleaner as a result.
* Fixed an bug in syslogd causing it to stop after 20 minutes. -erik
* Fixed an embarrasing segfault in head -beppu
* Fixed the embarrasing failure of 'logger -p'. -erik
* Added the -s option to du -beppu
* Re-worked the source tree a bit so it will compile under glibc 2.0.7
with the 2.0.x Linux kernel.
* Added 'grep -q' thanks to a patch from "Konstantin Boldyshev"
<konst@voshod.com>.
* Grep -i previously failed on UPPER CASE patterns due to a silly
regexp implementation bug that is now fixed.
* Fixed a bug where tar would set, and then clear SGID and SUID bits.
* Fixed a bug where tar would not set the user and group on device
special files.
* Fixed a bug where tar would not restore the time to files.
* Fixed a major security problem with tar -- it changed ownership
of any file pointed to by a symlink to 777 (like say libc....)
Ouch!!!
* cp and mv were very broken when moving directories. I have rewritten
them so they should now work as expected.
* sed now supports addresses (numeric or regexp, with negation) and
has an append command, thanks to Marco Pantaleoni <panta@prosa.it>
* Fixed dmesg. It wasn't parsing its options (-n or -s) properly.
* Some cosmetic fixes to ls output formatting to make it behave more
like GNU ls.
* Fixed a stupid segfault in kill.
* Several fixes from Friedrich Vedder <fwv@myrtle.lahn.de>:
- Added gunzip -t, removed gunzip.c dead code,
- fixed several typos
- Glibc 2.0.7 and libc5 compile fixes
* Fixed a bug where 'mknod --help' would segfault.
-Erik Andersen, Jan 07, 2000
0.39
* New Apps: ping, hostname, and mkfifo contributed by Randolph Chung
<tausq@debian.org>. 3 items off the TODO list!
* I wrote free (just calls "cat /proc/meminfo").
* Added tail, based on tail from GNU textutils-1.19, but adjusted
to suit my evil purposes. Costs 6k. I'll make it smaller sometime.
* on reboot, init called 'umount -a -n', which caused errors
when BB_MTAB was not enabled. Changed to 'umount -a',
which does the right thing.
* init will now try to run /sbin/getty if it is present (for easy
integration with the about-to-be-released tinylogin.)
* kill now behaves itself properly, added 'kill -l' to list signals
* 'ls -l' was failing on long directories, since my_getid was leaking
one file descriptor per file. Oops.
* Fixed rebooting from init. I'd accidently left some debugging code in
which blocked reboots.
* Fixed reboot, halt (and added poweroff) such that they handle it when
init is not at PID 1 (like when running in an initrd).
* Added a prelinary du implementation. Some parameter parsing
stuff still needs to be added. -beppu (John Beppu <beppu@lineo.com>)
* Implemented tee. -beppu
* Implemented head. -beppu
-Erik Andersen, Dec 10, 1999
0.38
* Fixed a segfault in 'umount -a' when a badly formed /etc/fstab
file existed.
* df will not exit on error, but will stat all mounted filesystems.
* Fixed tar so uid/gid/permissions on extracted tarballs will be correct.
* Fixed find -name so it properly uses shell wildcard patterns
(i.e. `*', `?', and `[]') instead of regular expressions, which
was causing some confusing and unexpected behavior.
* Added klogd to syslogd, so now the log will contain both system and
kernel messages.
* syslogd now creates the /dev/log socket to make sure it is there, and
is actually a socket with the right permissions.
* I've taken a first step to making busybox not need the /proc
filesystem. Most apps don't need it. Those that _require_ it,
will complain if you enable them when you disable
BB_FEATURE_USE_PROCFS.
-Erik Andersen, Dec 5, 1999
0.37
* Wrote a micro syslogd, and a logger util (to log things to the syslog
from the command line or scripts) With both compiled in, costs 4k.
* Fixed 'make install' so symlinks are installed in their proper locations.
* Changed the build system slightly so that features can now be enabled
or disabled from the busybox.defs.h header file, without trying to
compile in a source file named after that featue (unless that file exists).
* Several options are now moved into busybox.defs.h
* Now 'rm -R' and 'rm -r' both work.
* dd now properly handles input beyond 1 block from stdin.
* Fixed a bug where tar unpacked everything a directories. Moved some code
from createPath into mkdir where it belonged, thereby making tar work properly.
* Fixed an off-by-one bug in cat. Given a list of file it wouldn't cat out the
last file in the list.
* Fixed 'ls -ln' so numeric group/uid are presented properly, and fixed 'ls -l'
so when uid/gid is not in /etc/{passwd,group} the numeric group/uid are
presented properly.
* Also added a TODO.
-Erik Andersen, Nov 25, 1999
0.36
* fixed dd so it properly defaults to stdin and stdout when no
if= and of= are set (fix thanks to Eric Delaunay).
* Don't try to close the file descriptor of a pipein tar. (fix also from
Eric Delaunay).
* Made createPath be quiet (again thanks to Eric Delaunay).
* If BB_CONSOLE_CMD_IF_RC_SCRIPT_EXITS is defined, then whatever
command you define it as will be run if the init script exits.
* Updated install.sh to make it more robust (thanks to Adam Di Carlo)
* NFS support added to mount by Eric Delaunay. It costs 10k when compiled
in, but that is still a big win for those that use NFS.
* Made 'rm -f' be silent for non-existant files (thanks to Eric Delaunay).
* changed zcat.c to gunzip.c. It now obeys the principle of least surprise
and acts as god intended gunzip and zcat to act. They answer --help and
obey the '-c' flag.
* Fixed a bug in mv which caused it to not move files when the destination
was a directory.
* Fixed a decimal-instead-of-octal bug causing mkdir to make directories
with very wrong permissions.
* chmod would overwrite file permissions instead of modifying them.
Now it properly modifies permissions.
* Init now sends warnings destined for the console to /dev/console to ensure
they show up on whatever the active console it. Otherwise important
messages (for example that the system is rebooting) were not seen when
switched to a different VT.
-Erik Andersen, Nov 17, 1999
0.35
* gzip now obeys the principle of least surprise and acts like god intended
(i.e. it accepts a file name, answers --help, and obeys the '-c' flag
and only then outputs to stdout).
* Fixed more.c to compile autowidth on sparc and set initial winsize
to 0,0 in case the TIOCGWINSZ ioctl fails. Fix thanks to Eric Delaunay.
* Fixed tar so it now works as expected (it had TRUE/FALSE backwards)
* tar now accepts --help
* chmod, chown, and chgrp usage now works
* General usage (i.e. --help) cleanups for most apps
* umount now parses options correctly
* tar can now unpack tarballs containing device special files,
sockets, and fifos (though it can't pack them up) thanks
to Matt Porter. Creating archives containing these is still
left to the interested student.
* fixed up the license in more.c to properly point to Bruce Perens.
-Erik Andersen, Nov 11, 1999
0.34
* ls -l now displays link names outside the current directory,
Patch thanks to Eric Delaunay
* init now properly handles sparc serial consoles and does a
better job of finding the real console device rather than using
/dev/console which doesn't support job control. Patch also
thanks to Eric Delaunay.
* more started to read from stdin after the last file was finished, and
options were not parsed correctly (fix thanks to Eric Delaunay).
* more will now use the terminal size if BB_FEATURE_AUTOWIDTH is on.
* rm wouldn't remove a symlink unless the symlink was valid. This was
a side effect of the busybox 0.32 recursiveAction() fix. Things
should now work correctly.
* grep wouldn't grep stdin. Now it does.
* sed wouldn't sed stdin. Now it does.
* sed was appending a \n to the end of lines with replacements.
Now it doesn't do that.
* ls -l now bypasses libc6 nss when displaying user/group names.
Now uses my_getpwuid and my_getgrgid.
-Erik Andersen, Nov 8, 1999
0.33
* Fixed a bug where init could hang instead of rebooting.
* Removed some debugging noise from init.c
* Fixed ln so it works now (it was very broken).
* Fixed df so it won't segfault when there is no /etc/fstab,
* If BB_MTAB is not defined, df and mount will whine if /etc/fstab
is not installed (since they cannot fixup "/dev/root" to
state the real root device name)
* merged some redundant code from mtab.c/df.c into utility.c
-Erik Andersen, Nov 5, 1999
0.32
* usage() now printf the BusyBox version. This will help folks
* More changes -- many thanks to Lineo for paying me to work on
busybox. If you have any problems please let me know ASAP
at andersen@lineo.com or andersee@debian.org
* usage() now prints the BusyBox version. This will help folks
realize that they are not in Kansas anymore.
* Fixed mkdir -m option so that it works.
* kill segfaulted w/o any arguments. Now it doesn't do that.
@@ -22,7 +248,7 @@
as the name suggests. Fix thanks to Matt Porter <porter@debian.org>.
-Erik Andersen
-Erik Andersen, Nov 4, 1999
0.31
* I added a changelog for version 0.30.
@@ -37,7 +263,7 @@
it wasn't supported before GNU libc 2.1, and some folks use
glibc 2.0.7 since it is much smaller than that latest and greatest.
-Erik Andersen
-Erik Andersen, Oct 21, 1999
0.30
Major changes -- lots of stuff rewritten. Many thanks to Lineo for
@@ -106,7 +332,11 @@
* sfdisk -- Added from util-linux (minus internationalization and such).
* Probably some other changes that I forgot to document...
-Erik Andersen
-Erik Andersen, Oct 20, 1999
0.29
This version was a messy pre-alpha. stay away or it will bite you.
-Erik Andersen, Sep 24, 1999
0.28
mini-netcat (mnc) rewritten.
+353 -6
View File
@@ -17,15 +17,362 @@ Copyright 1998 Dave Cinege <dcinege@psychosis.com>
mini-gzip(gzip), mini-netcat(mnc)
Copyright 1998 Charles P. Wright <cpwright@villagenet.com>
bunches of stuff as noted in header files
Tons of new stuff as noted in header files
Copyright (C) 1999 by Lineo, inc. and written by
Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
copyright and license info.
This program suite may be distributed under the GNU General Public License.
Please send patches, suggestions, insults, and bribes to <andersee@debian.org>.
Please feed suggestions, bug reports, insults, and bribes back to:
Erik Andersen
<andersen@lineo.com>
<andersee@debian.org>
Busybox may be used and distributed under the GNU General Public License.
---------------------------------------------------------------------------
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
+61 -14
View File
@@ -17,7 +17,7 @@
PROG=busybox
VERSION=0.32
VERSION=0.41
BUILDTIME=$(shell date "+%Y%m%d-%H%M")
# Comment out the following to make a debuggable build
@@ -31,14 +31,54 @@ DOSTATIC=false
#This will choke on a non-debian system
ARCH=`uname -m | sed -e 's/i.86/i386/' | sed -e 's/sparc.*/sparc/'`
GCCMAJVERSION=$(shell $(CC) --version | sed -n "s/^\([^\.]*\).*/\1/p" )
GCCMINVERSION=$(shell $(CC) --version | sed -n "s/^[^\.]*\.\([^\.]*\)[\.].*/\1/p" )
GCCEGCS=$(shell $(CC) --version | sed -n "s/.*\(egcs\).*/\1/p" )
GCCSUPPORTSOPTSIZE=$(shell \
if ( test $(GCCMAJVERSION) -eq 2 ) ; then \
if ( test $(GCCMINVERSION) -ge 66 ) ; then \
echo "true"; \
else \
echo "false"; \
fi; \
else \
if ( test $(GCCMAJVERSION) -gt 2 ) ; then \
echo "true"; \
else \
echo "false"; \
fi; \
fi; )
GCCISEGCS=$(shell \
if ( test "x$(GCCEGCS)" == "xegcs" ) ; then \
echo "true"; \
else \
echo "false"; \
fi; )
EGCSEXTREMEFLAGS = -m386 -mcpu=i386 -march=i386 -malign-jumps=1 -malign-loops=1 -malign-functions=1
GCCEXTREMEFLAGS = -m386 -malign-jumps=1 -malign-loops=1 -malign-functions=1
ifeq ($(GCCISEGCS), true)
EXTREMEFLAGS = $(EGCSEXTREMEFLAGS)
else
EXTREMEFLAGS = $(GCCEXTREMEFLAGS)
endif
ifeq ($(GCCSUPPORTSOPTSIZE), true)
OPTIMIZATION=-Os $(EXTREMEFLAGS)
else
OPTIMIZATION=-O2 $(EXTREMEFLAGS)
endif
# -D_GNU_SOURCE is needed because environ is used in init.c
ifeq ($(DODEBUG),true)
CFLAGS=-Wall -g -D_GNU_SOURCE -DDEBUG_INIT
CFLAGS+=-Wall -g -D_GNU_SOURCE -DDEBUG_INIT
STRIP=
LDFLAGS=
else
CFLAGS=-Wall -Os -fomit-frame-pointer -fno-builtin -D_GNU_SOURCE
CFLAGS+=-Wall $(OPTIMIZATION) -fomit-frame-pointer -fno-builtin -D_GNU_SOURCE
LDFLAGS= -s
STRIP= strip --remove-section=.note --remove-section=.comment $(PROG)
#Only staticly link when _not_ debugging
@@ -48,35 +88,42 @@ else
endif
ifndef $(prefix)
prefix=`pwd`
ifndef $(PREFIX)
PREFIX=`pwd`/_install
endif
BINDIR=$(prefix)
LIBRARIES=
OBJECTS=$(shell ./busybox.sh)
CFLAGS+= -DBB_VER='"$(VERSION)"'
CFLAGS+= -DBB_BT='"$(BUILDTIME)"'
ifdef BB_INIT_SCRIPT
CFLAGS += -DINIT_SCRIPT=${BB_INIT_SCRIPT}
endif
all: busybox links
all: busybox busybox.links
busybox: $(OBJECTS)
$(CC) $(LDFLAGS) -o $(PROG) $(OBJECTS) $(LIBRARIES)
$(STRIP)
links:
- ./busybox.mkll | sort >busybox.links
busybox.links:
- ./busybox.mkll | sort >$@
clean:
- rm -f $(PROG) busybox.links *~ *.o core
- rm -rf _install
distclean: clean
- rm -f $(PROG)
force:
$(OBJECTS): busybox.def.h internal.h Makefile
install: $(PROG)
install.sh $(BINDIR)
install: busybox busybox.links
./install.sh $(PREFIX)
dist: release
release: distclean
(cd .. ; rm -rf busybox-$(VERSION) ; cp -a busybox busybox-$(VERSION); rm -rf busybox-$(VERSION)/CVS busybox-$(VERSION)/scripts/CVS busybox-$(VERSION)/docs/CVS busybox-$(VERSION)/.cvsignore ; tar -cvzf busybox-$(VERSION).tar.gz busybox-$(VERSION))
+23 -19
View File
@@ -1,26 +1,30 @@
Please see the LICENSE file for copyright information.
Busybox is a multicall binary used to provide a minimal subset of
POSIX style commands and specialized functions.
BusyBox is a suite of "tiny" Unix utilities in a multi-call binary. It
provides a pretty complete POSIX environment in a very small package.
Just add a kernel, "ash" (Keith Almquists tiny Bourne shell clone), and
an editor such as "elvis-tiny" or "ae", and you have a working system.
Busybox was begun to support the Debian Rescue/Install disks, but it
also makes an excellent environment for any small or embedded system.
It is geared toward the very small, i.e. boot floppies, embedded-
systems, etc. Specifically it is used in the Debian Rescue/Install
system (which caused the original busybox to be made), the Linux Router
Project, and others.
As of version 0.20 there is a version number. : ) Also as of version
0.20, BB is now modularized to easily allow you to build of only the
BB parts you need, thereby reducing binary size. To turn off unwanted
Busybox components, simply edit the file busybox.def.h and comment out
the parts you do not need using C++ style (//) comments.
As of version 0.20 there is a version number. : )
Also as of version 0.20, BB is modularized to allow an easy build of
only the BB parts you need, to reduce binary size.
After the build is complete a busybox.links file is generated which is
then used by 'make install' to create symlinks to the busybox binary
for all compiled in functions. By default, 'make install' will place
the symlink forest into `pwd`/_install unless you have defined the
PREFIX environment variable.
Edit the file busybox.def.h and comment out the parts you do not need
using C++ comments (//)
Please feed suggestions, bug reports, insults, and bribes back to:
Erik Andersen
<andersen@lineo.com>
<andersee@debian.org>
After the build is complete a busybox.links file is generated to allow
you to easily make the sym/hard links to the busybox binary.
<blatent plug>
Many thanks to go to Lineo for paying me to work on busybox.
</blatent plug>
Note the modular system is Makefile based, and purposely very
simplistic. It does no dependency checking. That is left for you
to figure out by trial and error.
Please feed patches back to:
Erik Andersen <andersee@deban.org>
+28
View File
@@ -0,0 +1,28 @@
TODO list for busybox in no particular order. Just because something
is listed here doesn't mean that it is going to be added to busybox,
or that doing so is even a good idea. It just means that I _might_ get
around to it some time. If you have any good ideas, please let me know.
* login/sulogin/passwd/getty/etc are part of tinylogin, and so are not
needed or wanted in busybox (or else I'd have to link in libcrypt).
* Networking apps are probably going to be split out some time soon into a
separate package (named perhaps tiny-netkit?). This currently includes
hostid, hostname, mnc, and ping.
-Erik
-----------
* Allow tar to create archives with sockets, devices, and other special files
* Make insmod actually work
* dnsdomainname
* traceroute/nslookup/netstat
* rdate
* hwclock
* killall
* stty
* tr
* expr (maybe?) (ash builtin?)
+110 -13
View File
@@ -3,8 +3,28 @@
#include <string.h>
#include <errno.h>
#ifndef BB_INIT
#undef BB_FEATURE_LINUXRC
#endif
static int been_there_done_that = 0;
/* It has been alledged that doing such things can
* help reduce binary size when staticly linking,
* of course with glibc, this is unlikely as long
* as we use things like printf -- perhaps a printf
* replacement may be in order
*/
#if 0
void exit (int status) __attribute__ ((noreturn));
void exit (int status) { _exit(status); };
void abort (void) __attribute__ ((__noreturn__));
void abort (void) { _exit(0); };
int atexit (void (*__func) (void)) { _exit(0); };
void *__libc_stack_end;
#endif
static const struct Applet applets[] = {
#ifdef BB_BUSYBOX //bin
@@ -27,6 +47,9 @@ static const struct Applet applets[] = {
#ifdef BB_CLEAR //usr/bin
{"clear", clear_main},
#endif
#ifdef BB_CHVT //usr/bin
{"chvt", chvt_main},
#endif
#ifdef BB_CP //bin
{"cp", cp_main},
#endif
@@ -42,17 +65,23 @@ static const struct Applet applets[] = {
#ifdef BB_DMESG //bin
{"dmesg", dmesg_main},
#endif
#ifdef BB_DU //bin
{"du", du_main},
#endif
#ifdef BB_DUTMP //usr/sbin
{"dutmp", dutmp_main},
#endif
#ifdef BB_FBSET //usr/sbin
{"fbset", fbset_main},
#endif
#ifdef BB_FDFLUSH //bin
{"fdflush", fdflush_main},
#endif
#ifdef BB_FIND //usr/bin
{"find", find_main},
#endif
#ifdef BB_CHVT //usr/bin
{"chvt", chvt_main},
#ifdef BB_FREE //usr/bin
{"free", free_main},
#endif
#ifdef BB_DEALLOCVT //usr/bin
{"deallocvt", deallocvt_main},
@@ -69,9 +98,24 @@ static const struct Applet applets[] = {
#ifdef BB_HALT //sbin
{"halt", halt_main},
#endif
#ifdef BB_HEAD //bin
{"head", head_main},
#endif
#ifdef BB_HOSTID //usr/bin
{"hostid", hostid_main},
#endif
#ifdef BB_HOSTNAME //bin
{"hostname", hostname_main},
#endif
#ifdef BB_INIT //sbin
{"init", init_main},
#endif
#ifdef BB_INSMOD //sbin
{"insmod", insmod_main},
#endif
#ifdef BB_FEATURE_LINUXRC //
{"linuxrc", init_main},
#endif
#ifdef BB_KILL //bin
{"kill", kill_main},
#endif
@@ -81,6 +125,9 @@ static const struct Applet applets[] = {
#ifdef BB_LN //bin
{"ln", ln_main},
#endif
#ifdef BB_LOADACM //usr/bin
{"loadacm", loadacm_main},
#endif
#ifdef BB_LOADFONT //usr/bin
{"loadfont", loadfont_main},
#endif
@@ -90,6 +137,9 @@ static const struct Applet applets[] = {
#ifdef BB_LS //bin
{"ls", ls_main},
#endif
#ifdef BB_LSMOD //sbin
{"lsmod", lsmod_main},
#endif
#ifdef BB_MAKEDEVS //sbin
{"makedevs", makedevs_main},
#endif
@@ -99,6 +149,9 @@ static const struct Applet applets[] = {
#ifdef BB_MKDIR //bin
{"mkdir", mkdir_main},
#endif
#ifdef BB_MKFIFO //usr/bin
{"mkfifo", mkfifo_main},
#endif
#ifdef BB_MKNOD //bin
{"mknod", mknod_main},
#endif
@@ -120,6 +173,12 @@ static const struct Applet applets[] = {
#ifdef BB_MV //bin
{"mv", mv_main},
#endif
#ifdef BB_PING //bin
{"ping", ping_main},
#endif
#ifdef BB_POWEROFF //sbin
{"poweroff", poweroff_main},
#endif
#ifdef BB_PRINTF //usr/bin
{"printf", printf_main},
#endif
@@ -138,6 +197,9 @@ static const struct Applet applets[] = {
#ifdef BB_RMDIR //bin
{"rmdir", rmdir_main},
#endif
#ifdef BB_RMMOD //sbin
{"rmmod", rmmod_main},
#endif
#ifdef BB_SFDISK //sbin
{"fdisk", sfdisk_main},
{"sfdisk", sfdisk_main},
@@ -148,15 +210,33 @@ static const struct Applet applets[] = {
#ifdef BB_SLEEP //bin
{"sleep", sleep_main},
#endif
#ifdef BB_TAR //bin
{"tar", tar_main},
#ifdef BB_SORT //bin
{"sort", sort_main},
#endif
#ifdef BB_SYNC //bin
{"sync", sync_main},
#endif
#ifdef BB_SYSLOGD //sbin
{"syslogd", syslogd_main},
#endif
#ifdef BB_LOGGER //usr/bin
{"logger", logger_main},
#endif
#ifdef BB_LOGNAME //usr/bin
{"logname", logname_main},
#endif
#ifdef BB_SWAPONOFF //sbin
{"swapon", swap_on_off_main},
{"swapoff", swap_on_off_main},
#endif
#ifdef BB_SYNC //bin
{"sync", sync_main},
#ifdef BB_TAIL //usr/bin
{"tail", tail_main},
#endif
#ifdef BB_TAR //bin
{"tar", tar_main},
#endif
#ifdef BB_TEE //bin
{"tee", tee_main},
#endif
#ifdef BB_TOUCH //usr/bin
{"touch", touch_main},
@@ -165,18 +245,33 @@ static const struct Applet applets[] = {
{"true", true_main},
{"false", false_main},
#endif
#ifdef BB_TTY //usr/bin
{"tty", tty_main},
#endif
#ifdef BB_UNAME //bin
{"uname", uname_main},
#endif
#ifdef BB_UMOUNT //bin
{"umount", umount_main},
#endif
#ifdef BB_UNIQ //bin
{"uniq", uniq_main},
#endif
#ifdef BB_UPDATE //sbin
{"update", update_main},
#endif
#ifdef BB_ZCAT //bin
{"zcat", zcat_main},
{"gunzip", zcat_main},
#ifdef BB_WC //usr/bin
{"wc", wc_main},
#endif
#ifdef BB_WHOAMI //usr/bin
{"whoami", whoami_main},
#endif
#ifdef BB_YES //usr/bin
{"yes", yes_main},
#endif
#ifdef BB_GUNZIP //bin
{"zcat", gunzip_main},
{"gunzip", gunzip_main},
#endif
#ifdef BB_GZIP //bin
{"gzip", gzip_main},
@@ -184,6 +279,8 @@ static const struct Applet applets[] = {
{0}
};
int main(int argc, char **argv)
{
char *s = argv[0];
@@ -220,12 +317,12 @@ int busybox_main(int argc, char **argv)
if (been_there_done_that == 1 || argc < 1) {
const struct Applet *a = applets;
fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n",
fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n",
BB_VER, BB_BT);
fprintf(stderr, "\nUsage:\t[function] [arguments]...\n");
fprintf(stderr, "\tbusybox [function] [arguments]...\n");
fprintf(stderr, "Usage: busybox [function] [arguments]...\n");
fprintf(stderr, " or: [function] [arguments]...\n\n");
fprintf(stderr,
"\n\tMost people will create a symlink to busybox for each\n"
"\tMost people will create a symlink to busybox for each\n"
"\tfunction name, and busybox will act like whatever you invoke it as.\n");
fprintf(stderr, "\nCurrently defined functions:\n");
+2 -2
View File
@@ -1,4 +1,4 @@
#!/bin/sh
sed -n '/^#define/{s/.*BB_//; s/$/.o/p; }' busybox.def.h | \
tr [:upper:] [:lower:]
ls -1 `sed -n '/^#define/{s/.*BB_// ; s/$/.c/p; }' busybox.def.h | \
tr [:upper:] [:lower:]` 2> /dev/null | sed -e 's/\.c$/\.o/g'
+20
View File
@@ -0,0 +1,20 @@
#!/bin/sh
set -e
if [ "$1" == "" ]; then
echo "No installation directory, aborting."
exit 1;
fi
h=`sort busybox.links | uniq`
for i in $h ; do
echo " $1$i -> /bin/busybox"
mkdir -p $1/`echo $i | sed -e 's/\/[^\/]*$//' `
ln -fs /bin/busybox $1$i
done
rm -f $1/bin/busybox
install -m 755 busybox $1/bin/busybox
exit 0
+144 -56
View File
@@ -4,11 +4,12 @@
#include "internal.h"
static const char zcat_usage[] = "zcat\n"
"\n"
"\tuncompress gzipped data from stdin to stdout\n";
static const char gunzip_usage[] =
"gunzip [OPTION]... FILE\n\n"
"Uncompress FILE (or standard input if FILE is '-').\n\n"
"Options:\n"
"\t-c\tWrite output to standard output\n"
"\t-t\tTest compressed file integrity\n";
/* gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
* Copyright (C) 1992-1993 Jean-loup Gailly
@@ -76,8 +77,6 @@ static char *license_msg[] = {
* The target dependent functions should be defined in tailor.c.
*/
/* $Id: zcat.c,v 1.5 1999/10/23 07:09:58 andersen Exp $ */
#define RECORD_IO 0
#define get_char() get_byte()
@@ -222,9 +221,6 @@ extern long bytes_in; /* number of input bytes */
extern long bytes_out; /* number of output bytes */
extern long header_bytes;/* number of bytes in gzip header */
extern int ifd; /* input file descriptor */
extern int ofd; /* output file descriptor */
extern long ifile_size; /* input file size, -1 for devices (debug only) */
typedef int file_t; /* Do not use stdio */
@@ -264,7 +260,6 @@ extern int exit_code; /* program exit code */
extern int verbose; /* be verbose (-v) */
extern int level; /* compression level */
extern int test; /* check .z file integrity */
extern int to_stdout; /* output to stdout (-c) */
extern int save_orig_name; /* set if original name must be saved */
#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf(0))
@@ -432,8 +427,6 @@ extern int unlzw OF((int in, int out));
# undef LZW
#endif
/* $Id: zcat.c,v 1.5 1999/10/23 07:09:58 andersen Exp $ */
/* #include "getopt.h" */
/* Declarations for getopt.
@@ -661,7 +654,7 @@ DECLARE(uch, window, 2L*WSIZE);
/* local variables */
int force = 0; /* don't ask questions, compress links (-f) */
int test_mode = 0; /* check file integrity option */
int foreground; /* set if program run in foreground */
int maxbits = BITS; /* max bits per code for LZW */
int method = DEFLATED;/* compression method */
@@ -685,18 +678,52 @@ long header_bytes; /* number of bytes in gzip header */
/* local functions */
local void treat_stdin OF((void));
local int get_method OF((int in));
local void do_exit OF((int exitcode));
int main OF((int argc, char **argv));
int (*work) OF((int infile, int outfile)) = unzip; /* function to call */
local void do_exit(int exitcode) __attribute__ ((noreturn));
#define strequ(s1, s2) (strcmp((s1),(s2)) == 0)
/* ======================================================================== */
int zcat_main (int argc, char * * argv)
int gunzip_main (int argc, char** argv)
{
int file_count; /* number of files to precess */
int to_stdout = 0;
int fromstdin = 0;
int result;
int inFileNum;
int outFileNum;
int delInputFile=0;
struct stat statBuf;
char* delFileName;
char ifname[MAX_PATH_LEN]; /* input file name */
char ofname[MAX_PATH_LEN]; /* output file name */
if (argc==1)
usage(gunzip_usage);
if (strcmp(*argv, "zcat")==0)
to_stdout = 1;
/* Parse any options */
while (--argc > 0 && **(++argv) == '-') {
if (*((*argv)+1) == '\0') {
fromstdin = 1;
to_stdout = 1;
}
while (*(++(*argv))) {
switch (**argv) {
case 'c':
to_stdout = 1;
break;
case 't':
test_mode = 1;
break;
default:
usage(gunzip_usage);
}
}
}
foreground = signal(SIGINT, SIG_IGN) != SIG_IGN;
if (foreground) {
@@ -727,31 +754,97 @@ int zcat_main (int argc, char * * argv)
ALLOC(ush, tab_prefix1, 1L<<(BITS-1));
#endif
/* And get to work */
treat_stdin();
if (fromstdin==1) {
strcpy(ofname, "stdin");
do_exit(exit_code);
return exit_code; /* just to avoid lint warning */
}
inFileNum=fileno(stdin);
ifile_size = -1L; /* convention for unknown size */
} else {
/* Open up the input file */
if (*argv=='\0')
usage(gunzip_usage);
strncpy(ifname, *argv, MAX_PATH_LEN);
/* ========================================================================
* Compress or decompress stdin
*/
local void treat_stdin()
{
ifile_size = -1L; /* convention for unknown size */
clear_bufs(); /* clear input and output buffers */
part_nb = 0;
method = get_method(ifd);
if (method < 0) {
do_exit(exit_code); /* error message already emitted */
/* Open input fille */
inFileNum=open( ifname, O_RDONLY);
if (inFileNum < 0) {
perror(ifname);
do_exit(WARNING);
}
/* Get the time stamp on the input file. */
result = stat(ifname, &statBuf);
if (result < 0) {
perror(ifname);
do_exit(WARNING);
}
ifile_size = statBuf.st_size;
}
(*work)(fileno(stdin), fileno(stdout));
if (to_stdout==1) {
/* And get to work */
strcpy(ofname, "stdout");
outFileNum=fileno(stdout);
clear_bufs(); /* clear input and output buffers */
part_nb = 0;
/* Actually do the compression/decompression. */
unzip(inFileNum, outFileNum);
} else if (test_mode) {
/* Actually do the compression/decompression. */
unzip(inFileNum, 2);
} else {
char* pos;
/* And get to work */
strncpy(ofname, ifname, MAX_PATH_LEN-4);
pos=strstr(ofname, ".gz");
if (pos != NULL) {
*pos='\0';
delInputFile=1;
} else {
pos=strstr(ofname, ".tgz");
if (pos != NULL) {
*pos='\0';
strcat( pos, ".tar");
delInputFile=1;
}
}
/* Open output fille */
#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
outFileNum=open( ofname, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW);
#else
outFileNum=open( ofname, O_RDWR|O_CREAT|O_EXCL);
#endif
if (outFileNum < 0) {
perror(ofname);
do_exit(WARNING);
}
/* Set permissions on the file */
fchmod(outFileNum, statBuf.st_mode);
clear_bufs(); /* clear input and output buffers */
part_nb = 0;
/* Actually do the compression/decompression. */
result=unzip(inFileNum, outFileNum);
close( outFileNum);
close( inFileNum);
/* Delete the original file */
if (result == OK)
delFileName=ifname;
else
delFileName=ofname;
if (delInputFile == 1 && unlink (delFileName) < 0) {
perror (delFileName);
exit( FALSE);
}
}
do_exit(exit_code);
}
@@ -772,17 +865,8 @@ local int get_method(in)
uch flags; /* compression flags */
char magic[2]; /* magic header */
/* If --force and --stdout, zcat == cat, so do not complain about
* premature end of file: use try_byte instead of get_byte.
*/
if (force) {
magic[0] = (char)try_byte();
magic[1] = (char)try_byte();
/* If try_byte returned EOF, magic[1] == 0xff */
} else {
magic[0] = (char)get_byte();
magic[1] = (char)get_byte();
}
magic[0] = (char)get_byte();
magic[1] = (char)get_byte();
method = -1; /* unknown yet */
part_nb++; /* number of parts in gzip file */
header_bytes = 0;
@@ -799,7 +883,6 @@ local int get_method(in)
exit_code = ERROR;
return -1;
}
work = unzip;
flags = (uch)get_byte();
(ulg)get_byte(); /* Ignore time stamp */
@@ -944,6 +1027,10 @@ int unzip(in, out)
ifd = in;
ofd = out;
method = get_method(ifd);
if (method < 0) {
do_exit(exit_code); /* error message already emitted */
}
updcrc(NULL, 0); /* initialize crc */
@@ -1029,7 +1116,7 @@ int unzip(in, out)
extern int errno;
#endif
const ulg crc_32_tab[]; /* crc table, defined below */
static const ulg crc_32_tab[]; /* crc table, defined below */
/* ===========================================================================
* Run a set of bytes through the crc shift register. If s is a NULL
@@ -1100,7 +1187,8 @@ void flush_outbuf()
{
if (outcnt == 0) return;
write_buf(ofd, (char *)outbuf, outcnt);
if (!test_mode)
write_buf(ofd, (char *)outbuf, outcnt);
bytes_out += (ulg)outcnt;
outcnt = 0;
}
@@ -1114,8 +1202,8 @@ void flush_window()
if (outcnt == 0) return;
updcrc(window, outcnt);
write_buf(ofd, (char *)window, outcnt);
if (!test_mode)
write_buf(ofd, (char *)window, outcnt);
bytes_out += (ulg)outcnt;
outcnt = 0;
}
@@ -1243,7 +1331,7 @@ voidp xmalloc (size)
/* ========================================================================
* Table of CRC-32's of all single-byte values (made by makecrc.c)
*/
const ulg crc_32_tab[] = {
static const ulg crc_32_tab[] = {
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
+117 -38
View File
@@ -7,11 +7,17 @@
#include "internal.h"
#ifdef BB_GZIP
#ifndef BB_ZCAT
#error you need zcat to have gzip support!
#endif
//#ifndef BB_ZCAT
//#error you need zcat to have gzip support!
//#endif
static const char gzip_usage[] =
"gzip [OPTION]... FILE\n\n"
"Compress FILE with maximum compression.\n"
"When FILE is -, reads standard input. Implies -c.\n\n"
"Options:\n"
"\t-c\tWrite output to standard output instead of FILE.gz\n";
static const char gzip_usage[] = "gzip\nignores all command line arguments\ncompress stdin to stdout with -9 compression\n";
/* gzip.h -- common declarations for all gzip modules
* Copyright (C) 1992-1993 Jean-loup Gailly.
@@ -210,7 +216,6 @@ extern int exit_code; /* program exit code */
extern int verbose; /* be verbose (-v) */
extern int quiet; /* be quiet (-q) */
extern int test; /* check .z file integrity */
extern int to_stdout; /* output to stdout (-c) */
extern int save_orig_name; /* set if original name must be saved */
#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf(0))
@@ -272,7 +277,7 @@ extern int save_orig_name; /* set if original name must be saved */
#define WARN(msg) {if (!quiet) fprintf msg ; \
if (exit_code == OK) exit_code = WARNING;}
local void do_exit(int exitcode);
local void do_exit(int exitcode) __attribute__ ((noreturn));
/* in zip.c: */
extern int zip OF((int in, int out));
@@ -380,7 +385,6 @@ extern int block_mode; /* block compress mode -C compatible with 2.0 */
# undef LZW
#endif
/* $Id: gzip.c,v 1.5 1999/10/23 07:09:58 andersen Exp $ */
/* tailor.h -- target dependent definitions
* Copyright (C) 1992-1993 Jean-loup Gailly.
* This is free software; you can redistribute it and/or modify it under the
@@ -391,7 +395,6 @@ extern int block_mode; /* block compress mode -C compatible with 2.0 */
* The target dependent functions should be defined in tailor.c.
*/
/* $Id: gzip.c,v 1.5 1999/10/23 07:09:58 andersen Exp $ */
#if defined(__MSDOS__) && !defined(MSDOS)
# define MSDOS
@@ -1728,7 +1731,6 @@ DECLARE(uch, window, 2L*WSIZE);
/* local variables */
int ascii = 0; /* convert end-of-lines to local OS conventions */
int to_stdout = 0; /* output to stdout (-c) */
int decompress = 0; /* decompress (-d) */
int no_name = -1; /* don't save or restore the original file name */
int no_time = -1; /* don't save or restore the original file time */
@@ -1760,17 +1762,42 @@ unsigned outcnt; /* bytes in output buffer */
/* local functions */
local void treat_stdin OF((void));
static int (*work) OF((int infile, int outfile)) = zip; /* function to call */
#define strequ(s1, s2) (strcmp((s1),(s2)) == 0)
/* ======================================================================== */
// int main (argc, argv)
// int argc;
// char **argv;
int gzip_main(int argc, char * * argv)
int gzip_main(int argc, char ** argv)
{
int result;
int inFileNum;
int outFileNum;
struct stat statBuf;
char* delFileName;
int tostdout = 0;
int fromstdin = 0;
if (argc==1)
usage(gzip_usage);
/* Parse any options */
while (--argc > 0 && **(++argv) == '-') {
if (*((*argv)+1) == '\0') {
fromstdin = 1;
tostdout = 1;
}
while (*(++(*argv))) {
switch (**argv) {
case 'c':
tostdout = 1;
break;
default:
usage(gzip_usage);
}
}
}
foreground = signal(SIGINT, SIG_IGN) != SIG_IGN;
if (foreground) {
(void) signal (SIGINT, (sig_type)abort_gzip);
@@ -1789,8 +1816,6 @@ int gzip_main(int argc, char * * argv)
strncpy(z_suffix, Z_SUFFIX, sizeof(z_suffix)-1);
z_len = strlen(z_suffix);
to_stdout = 1;
/* Allocate all global buffers (for DYN_ALLOC option) */
ALLOC(uch, inbuf, INBUFSIZ +INBUF_EXTRA);
ALLOC(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA);
@@ -1803,33 +1828,88 @@ int gzip_main(int argc, char * * argv)
ALLOC(ush, tab_prefix1, 1L<<(BITS-1));
#endif
/* And get to work */
treat_stdin();
do_exit(exit_code);
return exit_code; /* just to avoid lint warning */
}
if (fromstdin==1) {
strcpy(ofname, "stdin");
/* ========================================================================
* Compress or decompress stdin
*/
local void treat_stdin()
{
inFileNum=fileno(stdin);
time_stamp = 0; /* time unknown by default */
ifile_size = -1L; /* convention for unknown size */
} else {
/* Open up the input file */
if (*argv=='\0')
usage(gzip_usage);
strncpy(ifname, *argv, MAX_PATH_LEN);
/* Open input fille */
inFileNum=open( ifname, O_RDONLY);
if (inFileNum < 0) {
perror(ifname);
do_exit(WARNING);
}
/* Get the time stamp on the input file. */
result = stat(ifname, &statBuf);
if (result < 0) {
perror(ifname);
do_exit(WARNING);
}
time_stamp = statBuf.st_ctime;
ifile_size = statBuf.st_size;
}
if (tostdout==1) {
/* And get to work */
strcpy(ofname, "stdout");
outFileNum=fileno(stdout);
SET_BINARY_MODE(fileno(stdout));
strcpy(ifname, "stdin");
strcpy(ofname, "stdout");
/* Get the time stamp on the input file. */
time_stamp = 0; /* time unknown by default */
clear_bufs(); /* clear input and output buffers */
part_nb = 0;
ifile_size = -1L; /* convention for unknown size */
/* Actually do the compression/decompression. */
zip(inFileNum, outFileNum);
clear_bufs(); /* clear input and output buffers */
to_stdout = 1;
part_nb = 0;
} else {
/* Actually do the compression/decompression. Loop over zipped members.
*/
if ((*work)(fileno(stdin), fileno(stdout)) != OK) return;
/* And get to work */
strncpy(ofname, ifname, MAX_PATH_LEN-4);
strcat(ofname, ".gz");
/* Open output fille */
#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
outFileNum=open( ofname, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW);
#else
outFileNum=open( ofname, O_RDWR|O_CREAT|O_EXCL);
#endif
if (outFileNum < 0) {
perror(ofname);
do_exit(WARNING);
}
SET_BINARY_MODE(outFileNum);
/* Set permissions on the file */
fchmod(outFileNum, statBuf.st_mode);
clear_bufs(); /* clear input and output buffers */
part_nb = 0;
/* Actually do the compression/decompression. */
result=zip(inFileNum, outFileNum);
close( outFileNum);
close( inFileNum);
/* Delete the original file */
if (result == OK)
delFileName=ifname;
else
delFileName=ofname;
if (unlink (delFileName) < 0) {
perror (delFileName);
exit( FALSE);
}
}
do_exit(exit_code);
}
/* ========================================================================
@@ -2943,8 +3023,6 @@ local void set_file_type()
extern int errno;
#endif
extern ulg crc_32_tab[]; /* crc table, defined below */
/* ===========================================================================
* Copy input to output unchanged: zcat == cat with --force.
* IN assertion: insize bytes have already been read in inbuf.
@@ -3152,6 +3230,7 @@ int zip(in, out)
/* Write the header to the gzip file. See algorithm.doc for the format */
method = DEFLATED;
put_byte(GZIP_MAGIC[0]); /* magic header */
put_byte(GZIP_MAGIC[1]);
+157 -84
View File
@@ -10,6 +10,9 @@
* Modified for busybox by Erik Andersen <andersee@debian.org>
* Adjusted to grok stdin/stdout options.
*
* Modified to handle device special files by Matt Porter
* <porter@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
@@ -34,13 +37,17 @@
#include <fcntl.h>
#include <signal.h>
#include <time.h>
#include <utime.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
static const char tar_usage[] =
"tar -[cxtvOf] [tarFileName] [FILE] ...\n"
"Create, extract, or list files from a tar file\n\n"
"\tc=create, x=extract, t=list contents, v=verbose,\n"
"\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
"tar -[cxtvOf] [tarFileName] [FILE] ...\n\n"
"Create, extract, or list files from a tar file\n\n"
"Options:\n"
"\tc=create, x=extract, t=list contents, v=verbose,\n"
"\tO=extract to stdout, f=tarfile or \"-\" for stdin\n";
@@ -92,7 +99,7 @@ static int createFlag;
static int verboseFlag;
static int tostdoutFlag;
static int inHeader;
static int inHeader; // <- check me
static int badHeader;
static int errorFlag;
static int skipFileFlag;
@@ -100,8 +107,12 @@ static int warnedRoot;
static int eofFlag;
static long dataCc;
static int outFd;
static char outName[TAR_NAME_SIZE];
static const char *outName;
static int mode;
static int uid;
static int gid;
static time_t mtime;
/*
* Static data associated with the tar file.
@@ -169,10 +180,9 @@ extern int tar_main (int argc, char **argv)
/*
* Parse the options.
*/
options = *argv++;
argc--;
if (**argv == '-') {
options = (*argv++) + 1;
argc--;
for (; *options; options++) {
switch (*options) {
case 'f':
@@ -208,10 +218,13 @@ extern int tar_main (int argc, char **argv)
break;
case '-':
usage( tar_usage);
break;
default:
fprintf (stderr, "Unknown tar flag '%c'\n", *options);
fprintf (stderr, "Unknown tar flag '%c'\n"
"Try `tar --help' for more information\n",
*options);
exit (FALSE);
}
@@ -221,7 +234,7 @@ extern int tar_main (int argc, char **argv)
/*
* Validate the options.
*/
if (extractFlag + listFlag + createFlag != 1) {
if (extractFlag + listFlag + createFlag != (TRUE+FALSE+FALSE)) {
fprintf (stderr,
"Exactly one of 'c', 'x' or 't' must be specified\n");
@@ -232,13 +245,13 @@ extern int tar_main (int argc, char **argv)
* Do the correct type of action supplying the rest of the
* command line arguments as the list of files to process.
*/
if (createFlag)
if (createFlag==TRUE)
writeTarFile (argc, argv);
else
readTarFile (argc, argv);
if (errorFlag)
if (errorFlag==TRUE)
fprintf (stderr, "\n");
exit (errorFlag);
exit (!errorFlag);
}
@@ -269,7 +282,7 @@ static void readTarFile (int fileCount, char **fileTable)
* Open the tar file for reading.
*/
if ((tarName == NULL) || !strcmp (tarName, "-")) {
tarFd = STDIN;
tarFd = fileno(stdin);
} else
tarFd = open (tarName, O_RDONLY);
@@ -283,7 +296,7 @@ static void readTarFile (int fileCount, char **fileTable)
* Read blocks from the file until an end of file header block
* has been seen. (A real end of file from a read is an error.)
*/
while (!eofFlag) {
while (eofFlag==FALSE) {
/*
* Read the next block of data if necessary.
* This will be a large block if possible, which we will
@@ -310,7 +323,7 @@ static void readTarFile (int fileCount, char **fileTable)
/*
* If we are expecting a header block then examine it.
*/
if (inHeader) {
if (inHeader==TRUE) {
readHeader ((const TarHeader *) cp, fileCount, fileTable);
cp += TAR_BLOCK_SIZE;
@@ -356,8 +369,9 @@ static void readTarFile (int fileCount, char **fileTable)
* message is required on errors.
*/
if (tostdoutFlag == FALSE) {
if (outFd >= 0)
(void) close (outFd);
if (outFd >= 0) {
close (outFd);
}
}
}
@@ -370,26 +384,25 @@ static void readTarFile (int fileCount, char **fileTable)
static void
readHeader (const TarHeader * hp, int fileCount, char **fileTable)
{
int mode;
int uid;
int gid;
int checkSum;
long size;
time_t mtime;
const char *name;
int cc;
int hardLink;
int softLink;
int devFileFlag;
unsigned int major;
unsigned int minor;
long size;
struct utimbuf utb;
/*
* If the block is completely empty, then this is the end of the
* archive file. If the name is null, then just skip this header.
*/
name = hp->name;
outName = hp->name;
if (*name == '\0') {
if (*outName == '\0') {
for (cc = TAR_BLOCK_SIZE; cc > 0; cc--) {
if (*name++)
if (*outName++)
return;
}
@@ -408,9 +421,11 @@ readHeader (const TarHeader * hp, int fileCount, char **fileTable)
size = getOctal (hp->size, sizeof (hp->size));
mtime = getOctal (hp->mtime, sizeof (hp->mtime));
checkSum = getOctal (hp->checkSum, sizeof (hp->checkSum));
major = getOctal (hp->devMajor, sizeof (hp->devMajor));
minor = getOctal (hp->devMinor, sizeof (hp->devMinor));
if ((mode < 0) || (uid < 0) || (gid < 0) || (size < 0)) {
if (!badHeader)
if (badHeader==FALSE)
fprintf (stderr, "Bad tar header, skipping\n");
badHeader = TRUE;
@@ -420,6 +435,7 @@ readHeader (const TarHeader * hp, int fileCount, char **fileTable)
badHeader = FALSE;
skipFileFlag = FALSE;
devFileFlag = FALSE;
/*
* Check for the file modes.
@@ -431,22 +447,20 @@ readHeader (const TarHeader * hp, int fileCount, char **fileTable)
(hp->typeFlag == TAR_TYPE_SOFT_LINK - '0'));
/*
* Check for a directory or a regular file.
* Check for a directory.
*/
if (name[strlen (name) - 1] == '/')
if (outName[strlen (outName) - 1] == '/')
mode |= S_IFDIR;
else if ((mode & S_IFMT) == 0)
mode |= S_IFREG;
/*
* Check for absolute paths in the file.
* If we find any, then warn the user and make them relative.
*/
if (*name == '/') {
while (*name == '/')
name++;
if (*outName == '/') {
while (*outName == '/')
outName++;
if (!warnedRoot) {
if (warnedRoot==FALSE) {
fprintf (stderr,
"Absolute path detected, removing leading slashes\n");
}
@@ -458,9 +472,10 @@ readHeader (const TarHeader * hp, int fileCount, char **fileTable)
* See if we want this file to be restored.
* If not, then set up to skip it.
*/
if (!wantFileName (name, fileCount, fileTable)) {
if (!hardLink && !softLink && S_ISREG (mode)) {
inHeader = (size == 0);
if (wantFileName (outName, fileCount, fileTable) == FALSE) {
if ( !hardLink && !softLink && (S_ISREG (mode) || S_ISCHR (mode)
|| S_ISBLK (mode) || S_ISSOCK(mode) || S_ISFIFO(mode) ) ) {
inHeader = (size == 0)? TRUE : FALSE;
dataCc = size;
}
@@ -473,19 +488,23 @@ readHeader (const TarHeader * hp, int fileCount, char **fileTable)
* This file is to be handled.
* If we aren't extracting then just list information about the file.
*/
if (!extractFlag) {
if (verboseFlag) {
printf ("%s %3d/%-d %9ld %s %s", modeString (mode),
uid, gid, size, timeString (mtime), name);
} else
printf ("%s", name);
if (extractFlag==FALSE) {
if (verboseFlag==TRUE) {
printf ("%s %3d/%-d ", modeString (mode), uid, gid);
if( S_ISCHR (mode) || S_ISBLK (mode) )
printf ("%4d,%4d %s ", major,minor, timeString (mtime));
else
printf ("%9ld %s ", size, timeString (mtime));
}
printf ("%s", outName);
if (hardLink)
printf (" (link to \"%s\")", hp->linkName);
else if (softLink)
printf (" (symlink to \"%s\")", hp->linkName);
else if (S_ISREG (mode)) {
inHeader = (size == 0);
else if (S_ISREG (mode) || S_ISCHR (mode) || S_ISBLK (mode) ||
S_ISSOCK(mode) || S_ISFIFO(mode) ) {
inHeader = (size == 0)? TRUE : FALSE;
dataCc = size;
}
@@ -497,63 +516,106 @@ readHeader (const TarHeader * hp, int fileCount, char **fileTable)
/*
* We really want to extract the file.
*/
if (verboseFlag)
printf ("x %s\n", name);
if (verboseFlag==TRUE)
printf ("x %s\n", outName);
if (hardLink) {
if (link (hp->linkName, name) < 0)
perror (name);
if (link (hp->linkName, outName) < 0)
perror (outName);
/* Set the file time */
utb.actime = mtime;
utb.modtime = mtime;
utime (outName, &utb);
/* Set the file permissions */
chown(outName, uid, gid);
chmod(outName, mode);
return;
}
if (softLink) {
#ifdef S_ISLNK
if (symlink (hp->linkName, name) < 0)
perror (name);
if (symlink (hp->linkName, outName) < 0)
perror (outName);
/* Try to change ownership of the symlink.
* If libs doesn't support that, don't bother.
* Changing the pointed-to file is the Wrong Thing(tm).
*/
#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
lchown(outName, uid, gid);
#endif
/* Do not change permissions or date on symlink,
* since it changes the pointed to file instead. duh. */
#else
fprintf (stderr, "Cannot create symbolic links\n");
#endif
return;
}
/* Set the umask for this process so it doesn't
* screw things up. */
umask(0);
/*
* If the file is a directory, then just create the path.
*/
if (S_ISDIR (mode)) {
createPath (name, mode);
createPath (outName, mode);
/* Set the file time */
utb.actime = mtime;
utb.modtime = mtime;
utime (outName, &utb);
/* Set the file permissions */
chown(outName, uid, gid);
chmod(outName, mode);
return;
}
/*
* There is a file to write.
* First create the path to it if necessary with a default permission.
* First create the path to it if necessary with default permissions.
*/
createPath (name, 0777);
createPath (outName, 0777);
inHeader = (size == 0);
inHeader = (size == 0)? TRUE : FALSE;
dataCc = size;
/*
* Start the output file.
*/
if (tostdoutFlag == TRUE)
outFd = STDOUT;
else
outFd = open (name, O_WRONLY | O_CREAT | O_TRUNC, mode);
if (outFd < 0) {
perror (name);
skipFileFlag = TRUE;
return;
outFd = fileno(stdout);
else {
if ( S_ISCHR(mode) || S_ISBLK(mode) || S_ISSOCK(mode) ) {
devFileFlag = TRUE;
outFd = mknod (outName, mode, makedev(major, minor) );
}
else if (S_ISFIFO(mode) ) {
devFileFlag = TRUE;
outFd = mkfifo(outName, mode);
} else {
outFd = open (outName, O_WRONLY | O_CREAT | O_TRUNC, mode);
}
if (outFd < 0) {
perror (outName);
skipFileFlag = TRUE;
return;
}
/* Set the file time */
utb.actime = mtime;
utb.modtime = mtime;
utime (outName, &utb);
/* Set the file permissions */
chown(outName, uid, gid);
chmod(outName, mode);
}
/*
* If the file is empty, then that's all we need to do.
*/
if (size == 0 && tostdoutFlag == FALSE) {
(void) close (outFd);
if (size == 0 && (tostdoutFlag == FALSE) && (devFileFlag == FALSE)) {
close (outFd);
outFd = -1;
}
}
@@ -578,7 +640,7 @@ static void readData (const char *cp, int count)
* If we aren't extracting files or this file is being
* skipped then do nothing more.
*/
if (!extractFlag || skipFileFlag)
if (extractFlag==FALSE || skipFileFlag==TRUE)
return;
/*
@@ -587,7 +649,7 @@ static void readData (const char *cp, int count)
if (fullWrite (outFd, cp, count) < 0) {
perror (outName);
if (tostdoutFlag == FALSE) {
(void) close (outFd);
close (outFd);
outFd = -1;
}
skipFileFlag = TRUE;
@@ -595,13 +657,21 @@ static void readData (const char *cp, int count)
}
/*
* If the write failed, close the file and disable further
* writes to this file.
* Check if we are done writing to the file now.
*/
if (dataCc <= 0 && tostdoutFlag == FALSE) {
struct utimbuf utb;
if (close (outFd))
perror (outName);
/* Set the file time */
utb.actime = mtime;
utb.modtime = mtime;
utime (outName, &utb);
/* Set the file permissions */
chown(outName, uid, gid);
chmod(outName, mode);
outFd = -1;
}
}
@@ -627,7 +697,7 @@ static void writeTarFile (int fileCount, char **fileTable)
*/
if ((tarName == NULL) || !strcmp (tarName, "-")) {
tostdoutFlag = TRUE;
tarFd = STDOUT;
tarFd = fileno(stdout);
} else
tarFd = open (tarName, O_WRONLY | O_CREAT | O_TRUNC, 0666);
@@ -648,12 +718,12 @@ static void writeTarFile (int fileCount, char **fileTable)
tarDev = statbuf.st_dev;
tarInode = statbuf.st_ino;
/*
* Append each file name into the archive file.
* Follow symbolic links for these top level file names.
*/
while (!errorFlag && (fileCount-- > 0)) {
while (errorFlag==FALSE && (fileCount-- > 0)) {
saveFile (*fileTable++, FALSE);
}
@@ -682,10 +752,9 @@ static void writeTarFile (int fileCount, char **fileTable)
static void saveFile (const char *fileName, int seeLinks)
{
int status;
int mode;
struct stat statbuf;
if (verboseFlag)
if (verboseFlag==TRUE)
printf ("a %s\n", fileName);
/*
@@ -701,7 +770,7 @@ static void saveFile (const char *fileName, int seeLinks)
* Find out about the file.
*/
#ifdef S_ISLNK
if (seeLinks)
if (seeLinks==TRUE)
status = lstat (fileName, &statbuf);
else
#endif
@@ -732,12 +801,16 @@ static void saveFile (const char *fileName, int seeLinks)
return;
}
if (S_ISREG (mode)) {
saveRegularFile (fileName, &statbuf);
return;
}
/* Some day add support for tarring these up... but not today. :) */
// if (S_ISLNK(mode) || S_ISFIFO(mode) || S_ISBLK(mode) || S_ISCHR (mode) ) {
// fprintf (stderr, "%s: This version of tar can't store this type of file\n", fileName);
// }
/*
* The file is a strange type of file, ignore it.
@@ -801,7 +874,7 @@ saveRegularFile (const char *fileName, const struct stat *statbuf)
*/
cc = 0;
if (!sawEof) {
if (sawEof==FALSE) {
cc = fullRead (fileFd, data, dataCount);
if (cc < 0) {
@@ -890,7 +963,7 @@ static void saveDirectory (const char *dirName, const struct stat *statbuf)
* Read all of the directory entries and check them,
* except for the current and parent directory entries.
*/
while (!errorFlag && ((entry = readdir (dir)) != NULL)) {
while (errorFlag==FALSE && ((entry = readdir (dir)) != NULL)) {
if ((strcmp (entry->d_name, ".") == 0) ||
(strcmp (entry->d_name, "..") == 0)) {
continue;
@@ -989,7 +1062,7 @@ static void writeTarBlock (const char *buf, int len)
/*
* If we had a write error before, then do nothing more.
*/
if (errorFlag)
if (errorFlag==TRUE)
return;
/*
+110 -13
View File
@@ -3,8 +3,28 @@
#include <string.h>
#include <errno.h>
#ifndef BB_INIT
#undef BB_FEATURE_LINUXRC
#endif
static int been_there_done_that = 0;
/* It has been alledged that doing such things can
* help reduce binary size when staticly linking,
* of course with glibc, this is unlikely as long
* as we use things like printf -- perhaps a printf
* replacement may be in order
*/
#if 0
void exit (int status) __attribute__ ((noreturn));
void exit (int status) { _exit(status); };
void abort (void) __attribute__ ((__noreturn__));
void abort (void) { _exit(0); };
int atexit (void (*__func) (void)) { _exit(0); };
void *__libc_stack_end;
#endif
static const struct Applet applets[] = {
#ifdef BB_BUSYBOX //bin
@@ -27,6 +47,9 @@ static const struct Applet applets[] = {
#ifdef BB_CLEAR //usr/bin
{"clear", clear_main},
#endif
#ifdef BB_CHVT //usr/bin
{"chvt", chvt_main},
#endif
#ifdef BB_CP //bin
{"cp", cp_main},
#endif
@@ -42,17 +65,23 @@ static const struct Applet applets[] = {
#ifdef BB_DMESG //bin
{"dmesg", dmesg_main},
#endif
#ifdef BB_DU //bin
{"du", du_main},
#endif
#ifdef BB_DUTMP //usr/sbin
{"dutmp", dutmp_main},
#endif
#ifdef BB_FBSET //usr/sbin
{"fbset", fbset_main},
#endif
#ifdef BB_FDFLUSH //bin
{"fdflush", fdflush_main},
#endif
#ifdef BB_FIND //usr/bin
{"find", find_main},
#endif
#ifdef BB_CHVT //usr/bin
{"chvt", chvt_main},
#ifdef BB_FREE //usr/bin
{"free", free_main},
#endif
#ifdef BB_DEALLOCVT //usr/bin
{"deallocvt", deallocvt_main},
@@ -69,9 +98,24 @@ static const struct Applet applets[] = {
#ifdef BB_HALT //sbin
{"halt", halt_main},
#endif
#ifdef BB_HEAD //bin
{"head", head_main},
#endif
#ifdef BB_HOSTID //usr/bin
{"hostid", hostid_main},
#endif
#ifdef BB_HOSTNAME //bin
{"hostname", hostname_main},
#endif
#ifdef BB_INIT //sbin
{"init", init_main},
#endif
#ifdef BB_INSMOD //sbin
{"insmod", insmod_main},
#endif
#ifdef BB_FEATURE_LINUXRC //
{"linuxrc", init_main},
#endif
#ifdef BB_KILL //bin
{"kill", kill_main},
#endif
@@ -81,6 +125,9 @@ static const struct Applet applets[] = {
#ifdef BB_LN //bin
{"ln", ln_main},
#endif
#ifdef BB_LOADACM //usr/bin
{"loadacm", loadacm_main},
#endif
#ifdef BB_LOADFONT //usr/bin
{"loadfont", loadfont_main},
#endif
@@ -90,6 +137,9 @@ static const struct Applet applets[] = {
#ifdef BB_LS //bin
{"ls", ls_main},
#endif
#ifdef BB_LSMOD //sbin
{"lsmod", lsmod_main},
#endif
#ifdef BB_MAKEDEVS //sbin
{"makedevs", makedevs_main},
#endif
@@ -99,6 +149,9 @@ static const struct Applet applets[] = {
#ifdef BB_MKDIR //bin
{"mkdir", mkdir_main},
#endif
#ifdef BB_MKFIFO //usr/bin
{"mkfifo", mkfifo_main},
#endif
#ifdef BB_MKNOD //bin
{"mknod", mknod_main},
#endif
@@ -120,6 +173,12 @@ static const struct Applet applets[] = {
#ifdef BB_MV //bin
{"mv", mv_main},
#endif
#ifdef BB_PING //bin
{"ping", ping_main},
#endif
#ifdef BB_POWEROFF //sbin
{"poweroff", poweroff_main},
#endif
#ifdef BB_PRINTF //usr/bin
{"printf", printf_main},
#endif
@@ -138,6 +197,9 @@ static const struct Applet applets[] = {
#ifdef BB_RMDIR //bin
{"rmdir", rmdir_main},
#endif
#ifdef BB_RMMOD //sbin
{"rmmod", rmmod_main},
#endif
#ifdef BB_SFDISK //sbin
{"fdisk", sfdisk_main},
{"sfdisk", sfdisk_main},
@@ -148,15 +210,33 @@ static const struct Applet applets[] = {
#ifdef BB_SLEEP //bin
{"sleep", sleep_main},
#endif
#ifdef BB_TAR //bin
{"tar", tar_main},
#ifdef BB_SORT //bin
{"sort", sort_main},
#endif
#ifdef BB_SYNC //bin
{"sync", sync_main},
#endif
#ifdef BB_SYSLOGD //sbin
{"syslogd", syslogd_main},
#endif
#ifdef BB_LOGGER //usr/bin
{"logger", logger_main},
#endif
#ifdef BB_LOGNAME //usr/bin
{"logname", logname_main},
#endif
#ifdef BB_SWAPONOFF //sbin
{"swapon", swap_on_off_main},
{"swapoff", swap_on_off_main},
#endif
#ifdef BB_SYNC //bin
{"sync", sync_main},
#ifdef BB_TAIL //usr/bin
{"tail", tail_main},
#endif
#ifdef BB_TAR //bin
{"tar", tar_main},
#endif
#ifdef BB_TEE //bin
{"tee", tee_main},
#endif
#ifdef BB_TOUCH //usr/bin
{"touch", touch_main},
@@ -165,18 +245,33 @@ static const struct Applet applets[] = {
{"true", true_main},
{"false", false_main},
#endif
#ifdef BB_TTY //usr/bin
{"tty", tty_main},
#endif
#ifdef BB_UNAME //bin
{"uname", uname_main},
#endif
#ifdef BB_UMOUNT //bin
{"umount", umount_main},
#endif
#ifdef BB_UNIQ //bin
{"uniq", uniq_main},
#endif
#ifdef BB_UPDATE //sbin
{"update", update_main},
#endif
#ifdef BB_ZCAT //bin
{"zcat", zcat_main},
{"gunzip", zcat_main},
#ifdef BB_WC //usr/bin
{"wc", wc_main},
#endif
#ifdef BB_WHOAMI //usr/bin
{"whoami", whoami_main},
#endif
#ifdef BB_YES //usr/bin
{"yes", yes_main},
#endif
#ifdef BB_GUNZIP //bin
{"zcat", gunzip_main},
{"gunzip", gunzip_main},
#endif
#ifdef BB_GZIP //bin
{"gzip", gzip_main},
@@ -184,6 +279,8 @@ static const struct Applet applets[] = {
{0}
};
int main(int argc, char **argv)
{
char *s = argv[0];
@@ -220,12 +317,12 @@ int busybox_main(int argc, char **argv)
if (been_there_done_that == 1 || argc < 1) {
const struct Applet *a = applets;
fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n",
fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n",
BB_VER, BB_BT);
fprintf(stderr, "\nUsage:\t[function] [arguments]...\n");
fprintf(stderr, "\tbusybox [function] [arguments]...\n");
fprintf(stderr, "Usage: busybox [function] [arguments]...\n");
fprintf(stderr, " or: [function] [arguments]...\n\n");
fprintf(stderr,
"\n\tMost people will create a symlink to busybox for each\n"
"\tMost people will create a symlink to busybox for each\n"
"\tfunction name, and busybox will act like whatever you invoke it as.\n");
fprintf(stderr, "\nCurrently defined functions:\n");
+89 -16
View File
@@ -1,65 +1,138 @@
/*
* This file is parsed by sed. You MUST use single line comments.
* IE //#define BB_BLAH
*/
// This file defines the feature set to be compiled into busybox.
// When you turn things off here, they won't be compiled in at all.
//
//// This file is parsed by sed. You MUST use single line comments.
// i.e. //#define BB_BLAH
//
//
// BusyBox Applications
#define BB_BUSYBOX
#define BB_CAT
#define BB_CHMOD_CHOWN_CHGRP
#define BB_CHROOT
#define BB_CHVT
#define BB_CLEAR
#define BB_CP
#define BB_DATE
#define BB_DD
#define BB_DEALLOCVT
#define BB_DF
#define BB_DMESG
//#define BB_DUTMP
#define BB_DU
#define BB_FBSET
//#define BB_FDFLUSH
#define BB_FIND
#define BB_FREE
#define BB_FSCK_MINIX
#define BB_MKFS_MINIX
#define BB_CHVT
#define BB_DEALLOCVT
#define BB_GREP
#define BB_GUNZIP
#define BB_GZIP
//#define BB_HALT
#define BB_HEAD
//#define BB_HOSTID
#define BB_HOSTNAME
#define BB_INIT
// Don't turn BB_INSMOD on. It doesn't work.
//#define BB_INSMOD
#define BB_KILL
#define BB_KLOGD
//#define BB_LENGTH
#define BB_LN
#define BB_LOADFONT
#define BB_LOADKMAP
//#define BB_LOADACM
//#define BB_LOADFONT
//#define BB_LOADKMAP
//#define BB_LOGGER
#define BB_LOGNAME
#define BB_LS
#define BB_LSMOD
//#define BB_MAKEDEVS
#define BB_MKFS_MINIX
//#define BB_MATH
#define BB_MKDIR
//#define BB_MKFIFO
#define BB_MKNOD
#define BB_MKSWAP
//#define BB_MNC
#define BB_MORE
#define BB_MOUNT
#define BB_NFSMOUNT
//#define BB_MT
//#define BB_MTAB
#define BB_MV
#define BB_PING
#define BB_POWEROFF
//#define BB_PRINTF
#define BB_PS
#define BB_PWD
#define BB_REGEXP
#define BB_REBOOT
#define BB_REGEXP
#define BB_RM
#define BB_RMDIR
//#define BB_SFDISK
//#define BB_RMMOD
#define BB_SED
//#define BB_SFDISK
#define BB_SLEEP
#define BB_SORT
#define BB_SWAPONOFF
#define BB_SYNC
#define BB_SYSLOGD
#define BB_TAIL
#define BB_TAR
#define BB_TEE
#define BB_TOUCH
//#define BB_TRUE_FALSE // Supplied by ash
#define BB_TRUE_FALSE
#define BB_TTY
#define BB_WC
#define BB_WHOAMI
#define BB_UMOUNT
#define BB_UPDATE
#define BB_UNIQ
#define BB_UNAME
#define BB_ZCAT
//#define BB_GZIP
#define BB_UPDATE
#define BB_YES
// End of Applications List
//
//
//
// Don't turn BB_UTILITY off. It contains support code
// that compiles to 0 if everything else if turned off.
#define BB_UTILITY
//
//
//
// This is where feature definitions go. Generally speaking,
// turning this stuff off makes things a bit smaller (and less
// pretty/useful).
//
//
// enable features that use the /proc filesystem (apps that
// break without this will tell you on compile)...
#define BB_FEATURE_USE_PROCFS
//
// Use termios to manipulate the screen ('more' is prettier with this on)
#define BB_FEATURE_USE_TERMIOS
//
// calculate terminal & column widths (for more and ls)
#define BB_FEATURE_AUTOWIDTH
//
// show username/groupnames (bypasses libc6 NSS) for ls
#define BB_FEATURE_LS_USERNAME
//
// show file timestamps in ls
#define BB_FEATURE_LS_TIMESTAMPS
//
// enable ls -p and -F
#define BB_FEATURE_LS_FILETYPES
//
// Change ping implementation -- simplified, featureless, but really small.
//#define BB_SIMPLE_PING
////
// Make init use a simplified /etc/inittab file (recommended).
#define BB_FEATURE_USE_INITTAB
//
//Enable init being called as /linuxrc
#define BB_FEATURE_LINUXRC
//
// Enable support for loop devices in mount
#define BB_FEATURE_MOUNT_LOOP
//
+2 -2
View File
@@ -1,4 +1,4 @@
#!/bin/sh
sed -n '/^#define/{s/.*BB_//; s/$/.o/p; }' busybox.def.h | \
tr [:upper:] [:lower:]
ls -1 `sed -n '/^#define/{s/.*BB_// ; s/$/.c/p; }' busybox.def.h | \
tr [:upper:] [:lower:]` 2> /dev/null | sed -e 's/\.c$/\.o/g'
+4 -12
View File
@@ -1,5 +1,5 @@
Name: busybox
Version: 0.32
Version: 0.41
Release: 1
Group: System/Utilities
Summary: BusyBox is a tiny suite of Unix utilities in a multi-call binary.
@@ -7,7 +7,7 @@ Copyright: GPL
Packager : Erik Andersen <andersen@lineo.com>
Conflicts: fileutils grep shellutils
Buildroot: /tmp/%{Name}-%{Version}
Source: busybox-0.32.tar.gz
Source: %{Name}-%{Version}.tar.gz
%Description
BusyBox is a suite of "tiny" Unix utilities in a multi-call binary. It
@@ -18,22 +18,14 @@ is makes an excellent environment for a "rescue" disk or any small or
embedded system.
%Prep
%setup -q -n busybox
%setup -q -n %{Name}-%{Version}
%Build
make
%Install
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT/bin
h=`cat busybox.links`
for i in $h ; do
mkdir -p $RPM_BUILD_ROOT/`echo $i | sed -e 's/\(^.*\/\)\(.*\)/\1/g' `
(cd $RPM_BUILD_ROOT/bin ; ln -s busybox `echo $i | sed -e 's/\(^.*\/\)\(.*\)/\2/g' ` );
done
rm -f $RPM_BUILD_ROOT/bin/busybox
install -m 755 busybox $RPM_BUILD_ROOT/bin/busybox
make PREFIX=$RPM_BUILD_ROOT install
%Clean
rm -rf $RPM_BUILD_ROOT
-11
View File
@@ -1,11 +0,0 @@
#ifndef __BUSYBOX_FUNCTIONS_H__
#define __BUSYBOX_FUNCTIONS_H__
int
mkswap(char *device_name, int pages, int check);
/* pages = 0 for autodetection */
int
fdflush(char *filename);
#endif /* __BUSYBOX_FUNCTIONS_H__ */
+1 -4
View File
@@ -46,17 +46,14 @@ extern int cat_main(int argc, char **argv)
usage ("cat [file ...]\n");
}
argc--;
argv++;
while (argc-- > 0) {
while (argc-- > 0 && *(argv++) != '\0' && strlen(*argv) ) {
file = fopen(*argv, "r");
if (file == NULL) {
perror(*argv);
exit(FALSE);
}
print_file( file);
argc--;
argv++;
}
exit(TRUE);
}
+20 -20
View File
@@ -31,23 +31,23 @@ static uid_t uid=-1;
static gid_t gid=-1;
static int whichApp;
static char* invocationName=NULL;
static mode_t mode=0644;
static char* theMode=NULL;
#define CHGRP_APP 1
#define CHOWN_APP 2
#define CHMOD_APP 3
static const char chgrp_usage[] = "[OPTION]... GROUP FILE...\n"
static const char chgrp_usage[] = "chgrp [OPTION]... GROUP FILE...\n\n"
"Change the group membership of each FILE to GROUP.\n"
"\n\tOptions:\n" "\t-R\tchange files and directories recursively\n";
static const char chown_usage[] = "[OPTION]... OWNER[.[GROUP] FILE...\n"
"\nOptions:\n\t-R\tchange files and directories recursively\n";
static const char chown_usage[] = "chown [OPTION]... OWNER[.[GROUP] FILE...\n\n"
"Change the owner and/or group of each FILE to OWNER and/or GROUP.\n"
"\n\tOptions:\n" "\t-R\tchange files and directories recursively\n";
static const char chmod_usage[] = "[-R] MODE[,MODE]... FILE...\n"
"\nOptions:\n\t-R\tchange files and directories recursively\n";
static const char chmod_usage[] = "chmod [-R] MODE[,MODE]... FILE...\n\n"
"Each MODE is one or more of the letters ugoa, one of the symbols +-= and\n"
"one or more of the letters rwxst.\n\n"
"\t-R\tchange files and directories recursively.\n";
"\nOptions:\n\t-R\tchange files and directories recursively.\n";
static int fileAction(const char *fileName, struct stat* statbuf)
@@ -61,7 +61,12 @@ static int fileAction(const char *fileName, struct stat* statbuf)
}
break;
case CHMOD_APP:
if (chmod(fileName, mode) == 0)
/* Parse the specified modes */
if ( parse_mode(theMode, &(statbuf->st_mode)) == FALSE ) {
fprintf(stderr, "%s: Unknown mode: %s\n", invocationName, theMode);
exit( FALSE);
}
if (chmod(fileName, statbuf->st_mode) == 0)
return( TRUE);
break;
}
@@ -73,14 +78,14 @@ int chmod_chown_chgrp_main(int argc, char **argv)
{
int recursiveFlag=FALSE;
char *groupName;
const char *appUsage;
whichApp = (strcmp(*argv, "chown")==0)? CHOWN_APP : (strcmp(*argv, "chmod")==0)? CHMOD_APP : CHGRP_APP;
if (argc < 2) {
fprintf(stderr, "Usage: %s %s", *argv,
(whichApp==TRUE)? chown_usage : chgrp_usage);
exit( FALSE);
}
appUsage = (whichApp==CHOWN_APP)? chown_usage : (whichApp==CHMOD_APP)? chmod_usage : chgrp_usage;
if (argc < 2)
usage( appUsage);
invocationName=*argv;
argc--;
argv++;
@@ -93,19 +98,14 @@ int chmod_chown_chgrp_main(int argc, char **argv)
break;
default:
fprintf(stderr, "Unknown option: %c\n", **argv);
exit( FALSE);
usage( appUsage);
}
argc--;
argv++;
}
if ( whichApp == CHMOD_APP ) {
/* Find the specified modes */
mode = 0;
if ( parse_mode(*argv, &mode) == FALSE ) {
fprintf(stderr, "%s: Unknown mode: %s\n", invocationName, *argv);
exit( FALSE);
}
theMode=*argv;
} else {
/* Find the selected group */
+1 -1
View File
@@ -27,7 +27,7 @@
#include <errno.h>
static const char chroot_usage[] = "NEWROOT [COMMAND...]\n"
static const char chroot_usage[] = "chroot NEWROOT [COMMAND...]\n\n"
"Run COMMAND with root directory set to NEWROOT.\n";
+1 -1
View File
@@ -19,7 +19,7 @@ chvt_main(int argc, char** argv)
int fd, num;
if ( ( argc != 2) || (**(argv+1) == '-' ) ) {
usage ("chvt </dev/ttyN>\n");
usage ("chvt N\n\nChange foreground virtual terminal to /dev/ttyN\n");
}
fd = get_console_fd("/dev/console");
num = atoi(argv[1]);
+1 -1
View File
@@ -19,7 +19,7 @@ chvt_main(int argc, char** argv)
int fd, num;
if ( ( argc != 2) || (**(argv+1) == '-' ) ) {
usage ("chvt </dev/ttyN>\n");
usage ("chvt N\n\nChange foreground virtual terminal to /dev/ttyN\n");
}
fd = get_console_fd("/dev/console");
num = atoi(argv[1]);
+4 -2
View File
@@ -17,8 +17,10 @@ int
deallocvt_main(int argc, char *argv[]) {
int fd, num, i;
if (argc < 1) /* unlikely */
exit(1);
if ( ( argc != 2) || (**(argv+1) == '-' ) ) {
usage ("deallocvt N\n\nDeallocate unused virtual terminal /dev/ttyN\n");
}
progname = argv[0];
fd = get_console_fd("/dev/console");
+441
View File
@@ -0,0 +1,441 @@
/*
* Derived from
* mapscrn.c - version 0.92
*
* Was taken from console-tools and adapted by
* Peter Novodvorsky <petya@logic.ru>
*/
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/kd.h>
typedef unsigned short unicode;
static long int ctoi(unsigned char *s, int *is_unicode);
int old_screen_map_read_ascii(FILE *fp, unsigned char buf[]);
int uni_screen_map_read_ascii(FILE *fp, unicode buf[], int* is_unicode);
unicode utf8_to_ucs2 (char* buf);
int screen_map_load(int fd, FILE *fp);
int loadacm_main(int argc, char **argv)
{
int fd;
fd = open("/dev/tty", O_RDWR);
if (fd < 0) {
fprintf(stderr, "Error opening /dev/tty1: %s\n", strerror(errno));
return 1;
}
if (screen_map_load(fd, stdin))
{
fprintf(stderr, "Error loading acm: %s\n", strerror(errno));
return 1;
}
write(fd, "\033(K", 3);
return 0;
}
int screen_map_load(int fd, FILE *fp)
{
struct stat stbuf;
unicode wbuf[E_TABSZ];
unsigned char buf[E_TABSZ];
int parse_failed = 0;
int is_unicode;
if (fstat(fp->_fileno, &stbuf))
perror("Cannot stat map file"), exit(1);
/* first try a UTF screen-map: either ASCII (no restriction) or binary (regular file) */
if (!(parse_failed = (-1 == uni_screen_map_read_ascii(fp,wbuf,&is_unicode))) ||
(S_ISREG(stbuf.st_mode) &&
(stbuf.st_size == (sizeof(unicode) * E_TABSZ)))) /* test for binary UTF map by size */
{
if (parse_failed)
{
if (-1 == fseek (fp, 0, SEEK_SET))
{
if (errno == ESPIPE)
fprintf (stderr, "16bit screen-map MUST be a regular file.\n"), exit (1);
else
perror ("fseek failed reading binary 16bit screen-map"), exit (1);
}
if (fread(wbuf, sizeof(unicode) * E_TABSZ, 1, fp) != 1)
perror("Cannot read [new] map from file"), exit(1);
#if 0
else
fprintf(stderr, "Input screen-map is binary.\n");
#endif
}
/* if it was effectively a 16-bit ASCII, OK, else try to read as 8-bit map */
/* same if it was binary, ie. if parse_failed */
if (parse_failed || is_unicode)
{
if (ioctl(fd,PIO_UNISCRNMAP,wbuf))
perror("PIO_UNISCRNMAP ioctl"), exit(1);
else
return 0;
}
}
/* rewind... */
if (-1 == fseek (fp, 0, SEEK_SET))
{
if (errno == ESPIPE)
fprintf (stderr, "Assuming 8bit screen-map - MUST be a regular file.\n"), exit (1);
else
perror ("fseek failed assuming 8bit screen-map"), exit (1);
}
/* ... and try an old 8-bit screen-map */
if (!(parse_failed = (-1 == old_screen_map_read_ascii(fp,buf))) ||
(S_ISREG(stbuf.st_mode) &&
(stbuf.st_size == E_TABSZ))) /* test for binary old 8-bit map by size */
{
if (parse_failed)
{
if (-1 == fseek (fp, 0, SEEK_SET))
{
if (errno == ESPIPE)
/* should not - it succedeed above */
fprintf (stderr, "fseek() returned ESPIPE !\n"), exit (1);
else
perror ("fseek for binary 8bit screen-map"), exit (1);
}
if (fread(buf,E_TABSZ,1,fp) != 1)
perror("Cannot read [old] map from file"), exit(1);
#if 0
else
fprintf(stderr, "Input screen-map is binary.\n");
#endif
}
if (ioctl(fd,PIO_SCRNMAP,buf))
perror("PIO_SCRNMAP ioctl"), exit(1);
else
return 0;
}
else
{
fprintf(stderr, "Error parsing symbolic map\n");
exit(1);
}
}
/*
* - reads `fp' as a 16-bit ASCII SFM file.
* - returns -1 on error.
* - returns it in `unicode' in an E_TABSZ-elements array.
* - sets `*is_unicode' flagiff there were any non-8-bit
* (ie. real 16-bit) mapping.
*
* FIXME: ignores everything after second word
*/
int uni_screen_map_read_ascii(FILE *fp, unicode buf[], int *is_unicode)
{
char buffer[256]; /* line buffer reading file */
char *p, *q; /* 1st + 2nd words in line */
int in, on; /* the same, as numbers */
int tmp_is_unicode; /* tmp for is_unicode calculation */
int i; /* loop index - result holder */
int ret_code = 0; /* return code */
sigset_t sigset, old_sigset;
assert (is_unicode);
*is_unicode = 0;
/* first 128 codes defaults to ASCII */
for (i=0; i<128; i++) buf[i] = i;
/* remaining defaults to replacement char (usually E_TABSZ = 256) */
for ( ; i<E_TABSZ; i++) buf[i] = 0xfffd;
/* block SIGCHLD */
sigemptyset (&sigset);
sigaddset (&sigset, SIGCHLD);
sigprocmask (SIG_BLOCK, &sigset, &old_sigset);
do
{
if (NULL == fgets(buffer, sizeof(buffer),fp))
{
if (feof (fp))
break;
else
{
perror ("uni_screen_map_read_ascii() can't read line");
exit (2);
}
}
/* get "charset-relative charcode", stripping leading spaces */
p = strtok(buffer," \t\n");
/* skip empty lines and comments */
if (!p || *p == '#')
continue;
/* get unicode mapping */
q = strtok(NULL," \t\n");
if (q)
{
in = ctoi(p, NULL);
if (in < 0 || in > 255)
{
ret_code = -1;
break;
}
on = ctoi(q, &tmp_is_unicode);
if (in < 0 && on > 65535)
{
ret_code = -1;
break;
}
*is_unicode |= tmp_is_unicode;
buf[in] = on;
}
else
{
ret_code = -1;
break;
}
}
while (1); /* terminated by break on feof() */
/* restore sig mask */
sigprocmask (SIG_SETMASK, &old_sigset, NULL);
return ret_code;
}
int old_screen_map_read_ascii(FILE *fp, unsigned char buf[])
{
char buffer[256];
int in, on;
char *p, *q;
for (in=0; in<256; in++) buf[in]=in;
while (fgets(buffer,sizeof(buffer)-1,fp))
{
p = strtok(buffer," \t\n");
if (!p || *p == '#')
continue;
q = strtok(NULL," \t\n#");
if (q)
{
in = ctoi(p, NULL);
if (in < 0 || in > 255) return -1;
on = ctoi(q, NULL);
if (in < 0 && on > 255) return -1;
buf[in] = on;
}
else return -1;
}
return(0);
}
/*
* - converts a string into an int.
* - supports dec and hex bytes, hex UCS2, single-quoted byte and UTF8 chars.
* - returns the converted value
* - if `is_unicode != NULL', use it to tell whether it was unicode
*
* CAVEAT: will report valid UTF mappings using only 1 byte as 8-bit ones.
*/
long int ctoi(unsigned char *s, int *is_unicode)
{
int i;
size_t ls;
ls = strlen(s);
if (is_unicode) *is_unicode = 0;
/* hex-specified UCS2 */
if ((strncmp(s,"U+",2) == 0) &&
(strspn(s+2,"0123456789abcdefABCDEF") == ls-2))
{
sscanf(s+2,"%x",&i);
if (is_unicode) *is_unicode = 1;
}
/* hex-specified byte */
else if ((ls <= 4) && (strncmp(s,"0x",2) == 0) &&
(strspn(s+2,"0123456789abcdefABCDEF") == ls-2))
sscanf(s+2,"%x",&i);
/* oct-specified number (byte) */
else if ((*s == '0') &&
(strspn(s,"01234567") == ls))
sscanf(s,"%o",&i);
/* dec-specified number (byte) */
else if (strspn(s,"0123456789") == ls)
sscanf(s,"%d",&i);
/* single-byte quoted char */
else if ((strlen(s) == 3) && (s[0] == '\'') && (s[2] == '\''))
i=s[1];
/* multi-byte UTF8 quoted char */
else if ((s[0] == '\'') && (s[ls-1] == '\''))
{
s[ls-1] = 0; /* ensure we'll not "parse UTF too far" */
i = utf8_to_ucs2(s+1);
if (is_unicode) *is_unicode = 1;
}
else
return(-1);
return(i);
}
void saveoldmap(int fd, char *omfil)
{
FILE *fp;
char buf[E_TABSZ];
#ifdef GIO_UNISCRNMAP
unicode xbuf[E_TABSZ];
int is_old_map = 0;
if (ioctl(fd,GIO_UNISCRNMAP,xbuf))
{
perror("GIO_UNISCRNMAP ioctl error");
#endif
if (ioctl(fd,GIO_SCRNMAP,buf))
{
perror("GIO_SCRNMAP ioctl error");
exit(1);
}
else
is_old_map = 1;
#ifdef GIO_UNISCRNMAP
}
#endif
if ((fp = fopen(omfil, "w")) == NULL)
{
perror(omfil);
exit(1);
}
#ifdef GIO_UNISCRNMAP
if (is_old_map)
{
#endif
if (fwrite(buf,E_TABSZ,1,fp) != 1)
{
perror("Error writing map to file");
exit(1);
}
#ifdef GIO_UNISCRNMAP
}
else
if (fwrite(xbuf, sizeof(unicode) * E_TABSZ,1,fp) != 1)
{
perror("Error writing map to file");
exit(1);
}
#endif
fclose(fp);
}
unicode utf8_to_ucs2 (char* buf)
{
int utf_count = 0;
long utf_char;
unicode tc;
unsigned char c;
do
{
c = *buf;
buf++;
/* if byte should be part of multi-byte sequence */
if(c & 0x80)
{
/* if we have already started to parse a UTF8 sequence */
if (utf_count > 0 && (c & 0xc0) == 0x80)
{
utf_char = (utf_char << 6) | (c & 0x3f);
utf_count--;
if (utf_count == 0)
tc = utf_char;
else
continue;
}
else /* Possibly 1st char of a UTF8 sequence */
{
if ((c & 0xe0) == 0xc0)
{
utf_count = 1;
utf_char = (c & 0x1f);
}
else if ((c & 0xf0) == 0xe0)
{
utf_count = 2;
utf_char = (c & 0x0f);
}
else if ((c & 0xf8) == 0xf0)
{
utf_count = 3;
utf_char = (c & 0x07);
}
else if ((c & 0xfc) == 0xf8)
{
utf_count = 4;
utf_char = (c & 0x03);
}
else if ((c & 0xfe) == 0xfc)
{
utf_count = 5;
utf_char = (c & 0x01);
}
else
utf_count = 0;
continue;
}
}
else /* not part of multi-byte sequence - treat as ASCII
* this makes incomplete sequences to be ignored
*/
{
tc = c;
utf_count = 0;
}
}
while (utf_count);
return tc;
}
+1 -4
View File
@@ -46,17 +46,14 @@ extern int cat_main(int argc, char **argv)
usage ("cat [file ...]\n");
}
argc--;
argv++;
while (argc-- > 0) {
while (argc-- > 0 && *(argv++) != '\0' && strlen(*argv) ) {
file = fopen(*argv, "r");
if (file == NULL) {
perror(*argv);
exit(FALSE);
}
print_file( file);
argc--;
argv++;
}
exit(TRUE);
}
+1 -1
View File
@@ -27,7 +27,7 @@
#include <errno.h>
static const char chroot_usage[] = "NEWROOT [COMMAND...]\n"
static const char chroot_usage[] = "chroot NEWROOT [COMMAND...]\n\n"
"Run COMMAND with root directory set to NEWROOT.\n";
+27 -15
View File
@@ -28,12 +28,12 @@
#include <dirent.h>
static const char cp_usage[] = "cp [OPTION]... SOURCE DEST\n"
" or: cp [OPTION]... SOURCE... DIRECTORY\n"
" or: cp [OPTION]... SOURCE... DIRECTORY\n\n"
"Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.\n"
"\n"
"\t-a\tsame as -dpR\n"
"\t-d\tpreserve links\n"
"\t-p\tpreserve file attributes if possable\n"
"\t-p\tpreserve file attributes if possible\n"
"\t-R\tcopy directories recursively\n";
@@ -42,25 +42,39 @@ static int followLinks = FALSE;
static int preserveFlag = FALSE;
static const char *srcName;
static const char *destName;
static const char *skipName;
static int dirFlag = FALSE;
static int destDirFlag = FALSE;
static int srcDirFlag = FALSE;
static int fileAction(const char *fileName, struct stat* statbuf)
{
char newdestName[NAME_MAX];
char* newsrcName = NULL;
strcpy(newdestName, destName);
if (dirFlag==TRUE) {
strcat(newdestName, "/");
if ( skipName != NULL)
strcat(newdestName, strstr(fileName, skipName));
if ( srcDirFlag == TRUE ) {
if (recursiveFlag!=TRUE ) {
fprintf(stderr, "cp: %s: omitting directory\n", srcName);
return( TRUE);
}
strcat(newdestName, strstr(fileName, srcName) + strlen(srcName));
}
if (destDirFlag==TRUE && srcDirFlag == FALSE) {
if (newdestName[strlen(newdestName)-1] != '/' ) {
strcat(newdestName, "/");
}
newsrcName = strrchr(srcName, '/');
if (newsrcName && *newsrcName != '\0')
strcat(newdestName, newsrcName);
else
strcat(newdestName, srcName);
}
return (copyFile(fileName, newdestName, preserveFlag, followLinks));
}
extern int cp_main(int argc, char **argv)
{
if (argc < 3) {
usage (cp_usage);
}
@@ -94,18 +108,16 @@ extern int cp_main(int argc, char **argv)
destName = argv[argc - 1];
dirFlag = isDirectory(destName);
destDirFlag = isDirectory(destName);
if ((argc > 3) && dirFlag==FALSE) {
if ((argc > 3) && destDirFlag==FALSE) {
fprintf(stderr, "%s: not a directory\n", destName);
exit (FALSE);
}
while (argc-- > 1) {
srcName = *(argv++);
skipName = strrchr(srcName, '/');
if (skipName)
skipName++;
srcDirFlag = isDirectory(srcName);
if (recursiveAction(srcName, recursiveFlag, followLinks, FALSE,
fileAction, fileAction) == FALSE) {
exit( FALSE);
+1 -1
View File
@@ -35,7 +35,7 @@
mail commands */
static const char date_usage[] = "date [OPTION]... [+FORMAT]\n"
" or: date [OPTION] [MMDDhhmm[[CC]YY][.ss]]\n"
" or: date [OPTION] [MMDDhhmm[[CC]YY][.ss]]\n\n"
"Display the current time in the given FORMAT, or set the system date.\n"
"\nOptions:\n\t-R\t\toutput RFC-822 compliant date string\n"
"\t-s\t\tset time described by STRING\n"
+30 -70
View File
@@ -29,12 +29,18 @@
#include "internal.h"
#include <features.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
#include <inttypes.h>
#else
typedef unsigned long long int uintmax_t;
#endif
static const char dd_usage[] =
"dd [if=name] [of=name] [bs=n] [count=n]\n"
"dd [if=name] [of=name] [bs=n] [count=n]\n\n"
"Copy a file, converting and formatting according to options\n\n"
"\tif=FILE\tread from FILE instead of stdin\n"
"\tof=FILE\twrite to FILE instead of stout\n"
@@ -42,77 +48,26 @@ static const char dd_usage[] =
"\tcount=n\tcopy only n input blocks\n"
//"\tskip=n\tskip n input blocks\n"
"\n"
"BYTES may be suffixed: by k for x1024, b for x512, and w for x2.\n";
"BYTES may be suffixed by w (x2), k (x1024), b (x512), or m (x1024^2).\n";
/*
* Read a number with a possible multiplier.
* Returns -1 if the number format is illegal.
*/
static long getNum (const char *cp)
{
long value;
if (!isDecimal (*cp))
return -1;
value = 0;
while (isDecimal (*cp))
value = value * 10 + *cp++ - '0';
switch (*cp++) {
case 'k':
value *= 1024;
break;
case 'b':
value *= 512;
break;
case 'w':
value *= 2;
break;
case '\0':
return value;
default:
return -1;
}
if (*cp)
return -1;
return value;
}
extern int dd_main (int argc, char **argv)
{
const char *inFile;
const char *outFile;
const char *inFile = NULL;
const char *outFile = NULL;
char *cp;
int inFd;
int outFd;
int inCc = 0;
int outCc;
int skipBlocks;
int blockSize;
long count;
long intotal;
long outTotal;
size_t blockSize = 512;
//uintmax_t skipBlocks = 0;
uintmax_t count = (uintmax_t)-1;
uintmax_t intotal;
uintmax_t outTotal;
unsigned char *buf;
inFile = NULL;
outFile = NULL;
blockSize = 512;
skipBlocks = 0;
count = 1;
argc--;
argv++;
@@ -125,14 +80,14 @@ extern int dd_main (int argc, char **argv)
else if (strncmp("count", *argv, 5) == 0) {
count = getNum ((strchr(*argv, '='))+1);
if (count <= 0) {
fprintf (stderr, "Bad count value %ld\n", count);
fprintf (stderr, "Bad count value %s\n", *argv);
goto usage;
}
}
else if (strncmp(*argv, "bs", 2) == 0) {
blockSize = getNum ((strchr(*argv, '='))+1);
if (blockSize <= 0) {
fprintf (stderr, "Bad block size value %d\n", blockSize);
fprintf (stderr, "Bad block size value %s\n", *argv);
goto usage;
}
}
@@ -152,8 +107,6 @@ extern int dd_main (int argc, char **argv)
argc--;
argv++;
}
if ( inFile == NULL || outFile == NULL)
goto usage;
buf = malloc (blockSize);
if (buf == NULL) {
@@ -165,7 +118,7 @@ extern int dd_main (int argc, char **argv)
outTotal = 0;
if (inFile == NULL)
inFd = STDIN;
inFd = fileno(stdin);
else
inFd = open (inFile, 0);
@@ -176,7 +129,7 @@ extern int dd_main (int argc, char **argv)
}
if (outFile == NULL)
outFd = STDOUT;
outFd = fileno(stdout);
else
outFd = creat (outFile, 0666);
@@ -188,11 +141,17 @@ extern int dd_main (int argc, char **argv)
}
//lseek(inFd, skipBlocks*blockSize, SEEK_SET);
//
//TODO: Convert to using fullRead & fullWrite
// from utilitity.c
// -Erik
while (outTotal < count * blockSize) {
inCc = read (inFd, buf, blockSize);
if (inCc < 0) {
perror (inFile);
goto cleanup;
} else if (inCc == 0) {
goto cleanup;
}
intotal += inCc;
cp = buf;
@@ -204,6 +163,8 @@ extern int dd_main (int argc, char **argv)
if (outCc < 0) {
perror (outFile);
goto cleanup;
} else if (outCc == 0) {
goto cleanup;
}
inCc -= outCc;
@@ -220,15 +181,14 @@ extern int dd_main (int argc, char **argv)
close (outFd);
free (buf);
printf ("%ld+%d records in\n", intotal / blockSize,
printf ("%ld+%d records in\n", (long)(intotal / blockSize),
(intotal % blockSize) != 0);
printf ("%ld+%d records out\n", outTotal / blockSize,
printf ("%ld+%d records out\n", (long)(outTotal / blockSize),
(outTotal % blockSize) != 0);
exit( TRUE);
usage:
fprintf (stderr, "%s", dd_usage);
exit( FALSE);
usage( dd_usage);
}
+14 -53
View File
@@ -38,19 +38,23 @@ static int df(char *device, const char *mountPoint)
struct statfs s;
long blocks_used;
long blocks_percent_used;
struct fstab* fstabItem;
if (statfs(mountPoint, &s) != 0) {
perror(mountPoint);
return 1;
return FALSE;
}
if (s.f_blocks > 0) {
blocks_used = s.f_blocks - s.f_bfree;
blocks_percent_used = (long)
(blocks_used * 100.0 / (blocks_used + s.f_bavail) + 0.5);
if (strcmp(device, "/dev/root") == 0)
device = (getfsfile("/"))->fs_spec;
/* Note that if /etc/fstab is missing, libc can't fix up /dev/root for us */
if (strcmp (device, "/dev/root") == 0) {
fstabItem = getfsfile ("/");
if (fstabItem != NULL)
device = fstabItem->fs_spec;
}
printf("%-20s %9ld %9ld %9ld %3ld%% %s\n",
device,
(long) (s.f_blocks * (s.f_bsize / 1024.0)),
@@ -60,50 +64,9 @@ static int df(char *device, const char *mountPoint)
}
return 0;
return TRUE;
}
/*
* Given a block device, find the mount table entry if that block device
* is mounted.
*
* Given any other file (or directory), find the mount table entry for its
* filesystem.
*/
extern struct mntent *findMountPoint(const char *name, const char *table)
{
struct stat s;
dev_t mountDevice;
FILE *mountTable;
struct mntent *mountEntry;
if (stat(name, &s) != 0)
return 0;
if ((s.st_mode & S_IFMT) == S_IFBLK)
mountDevice = s.st_rdev;
else
mountDevice = s.st_dev;
if ((mountTable = setmntent(table, "r")) == 0)
return 0;
while ((mountEntry = getmntent(mountTable)) != 0) {
if (strcmp(name, mountEntry->mnt_dir) == 0
|| strcmp(name, mountEntry->mnt_fsname) == 0) /* String match. */
break;
if (stat(mountEntry->mnt_fsname, &s) == 0 && s.st_rdev == mountDevice) /* Match the device. */
break;
if (stat(mountEntry->mnt_dir, &s) == 0 && s.st_dev == mountDevice) /* Match the directory's mount point. */
break;
}
endmntent(mountTable);
return mountEntry;
}
extern int df_main(int argc, char **argv)
{
printf("%-20s %-14s %s %s %s %s\n", "Filesystem",
@@ -117,15 +80,15 @@ extern int df_main(int argc, char **argv)
if ((mountEntry = findMountPoint(argv[1], mtab_file)) ==
0) {
fprintf(stderr, "%s: can't find mount point.\n", argv[1]);
return 1;
exit( FALSE);
}
status = df(mountEntry->mnt_fsname, mountEntry->mnt_dir);
if (status != 0)
return status;
exit( status);
argc--;
argv++;
}
return 0;
exit( TRUE);
} else {
FILE *mountTable;
struct mntent *mountEntry;
@@ -137,12 +100,10 @@ extern int df_main(int argc, char **argv)
}
while ((mountEntry = getmntent(mountTable))) {
int status = df(mountEntry->mnt_fsname, mountEntry->mnt_dir);
if (status)
return status;
df(mountEntry->mnt_fsname, mountEntry->mnt_dir);
}
endmntent(mountTable);
}
return 0;
exit( TRUE);
}
+143
View File
@@ -0,0 +1,143 @@
/*
* Mini du implementation for busybox
*
*
* Copyright (C) 1999 by Lineo, inc.
* Written by John Beppu <beppu@lineo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <sys/types.h>
#include <fcntl.h>
#include <dirent.h>
#include <stdio.h>
#include <errno.h>
#if 0
#include <unistd.h>
#include <sys/stat.h>
#endif
typedef void (Display)(size_t, char *);
static const char du_usage[] =
"Usage: du [OPTION]... [FILE]...\n\n"
"\t-s\tdisplay only a total for each argument\n"
;
static int du_depth = 0;
static Display *print;
static void
print_normal(size_t size, char *filename)
{
fprintf(stdout, "%-7d %s\n", (size >> 1), filename);
}
static void
print_summary(size_t size, char *filename)
{
if (du_depth == 1) {
print_normal(size, filename);
}
}
/* tiny recursive du */
static size_t
du(char *filename)
{
struct stat statbuf;
size_t sum;
if ((lstat(filename, &statbuf)) != 0) {
fprintf(stdout, "du: %s: %s\n", filename, strerror(errno));
return 0;
}
du_depth++;
sum = statbuf.st_blocks;
if (S_ISDIR(statbuf.st_mode)) {
DIR *dir;
struct dirent *entry;
dir = opendir(filename);
if (!dir) { return 0; }
while ((entry = readdir(dir))) {
char newfile[512];
char *name = entry->d_name;
if ( (strcmp(name, "..") == 0)
|| (strcmp(name, ".") == 0))
{ continue; }
sprintf(newfile, "%s/%s", filename, name);
sum += du(newfile);
}
closedir(dir);
print(sum, filename);
}
du_depth--;
return sum;
}
int
du_main(int argc, char **argv)
{
int i;
char opt;
/* default behaviour */
print = print_normal;
/* parse argv[] */
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
opt = argv[i][1];
switch (opt) {
case 's':
print = print_summary;
break;
case 'h':
usage(du_usage);
break;
default:
fprintf(stderr, "du: invalid option -- %c\n", opt);
usage(du_usage);
}
} else {
break;
}
}
/* go through remaining args (if any) */
if (i >= argc) {
du(".");
} else {
int sum;
for ( ; i < argc; i++) {
sum = du(argv[i]);
if ((sum) && (isDirectory(argv[i]))) { print_normal(sum, argv[i]); }
}
}
exit(0);
}
/* $Id: du.c,v 1.8 1999/12/17 18:44:15 erik Exp $ */
+106
View File
@@ -0,0 +1,106 @@
/*
* Mini head implementation for busybox
*
*
* Copyright (C) 1999 by Lineo, inc.
* Written by John Beppu <beppu@lineo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <errno.h>
#include <stdio.h>
const char head_usage[] =
"Usage: head [FILE]...\n\n"
"Print first 10 lines of each FILE to standard output.\n"
"With more than one FILE, precede each with a header giving the\n"
"file name. With no FILE, or when FILE is -, read standard input.\n";
int
head(int len, FILE *src)
{
int i;
char buffer[1024];
for (i = 0; i < len; i++) {
fgets(buffer, 1024, src);
if (feof(src)) { break; }
fputs(buffer, stdout);
}
return 0;
}
/* BusyBoxed head(1) */
int
head_main(int argc, char **argv)
{
int i = 1;
char opt;
int len = 10;
/* 1st option is potentially special */
if ((argc > 1) && (argv[1][0] == '-') && isDecimal(argv[1][1])) {
int tmplen = atoi(&argv[1][1]);
if (tmplen) { len = tmplen; }
i = 2;
}
/* parse argv[] */
for ( ; i < argc; i++) {
if (argv[i][0] == '-') {
opt = argv[i][1];
switch (opt) {
case '-':
case 'h':
usage(head_usage);
default:
fprintf(stderr, "head: invalid option -- %c\n", opt);
usage(head_usage);
}
} else {
break;
}
}
/* get rest of argv[] or stdin if nothing's left */
if (i >= argc) {
head(len, stdin);
} else {
int need_headers = ((argc - i) > 1);
for ( ; i < argc; i++) {
FILE *src;
src = fopen(argv[i], "r");
if (!src) {
fprintf(stderr,"head: %s: %s\n", argv[i], strerror(errno));
} else {
/* emulating GNU behaviour */
if (need_headers) {
fprintf(stdout, "==> %s <==\n", argv[i]);
}
head(len, src);
if (i < argc - 1) {
fprintf(stdout, "\n");
}
}
}
}
exit(0);
}
/* $Id: head.c,v 1.4 1999/12/17 18:52:06 erik Exp $ */
+28
View File
@@ -0,0 +1,28 @@
/*
* Mini hostid implementation for busybox
*
* Copyright (C) 2000 Edward Betts <edward@debian.org>.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
extern int hostid_main(int argc, char **argv) {
printf ("%lx\n", gethostid());
exit( TRUE);
}
+14 -19
View File
@@ -27,23 +27,21 @@
#include <errno.h>
static const char ln_usage[] = "ln [-s] [-f] original-name additional-name\n"
"\n"
"\tAdd a new name that refers to the same file as \"original-name\"\n"
"\n"
"\t-s:\tUse a \"symbolic\" link, instead of a \"hard\" link.\n"
"\t-f:\tRemove existing destination files.\n";
static const char ln_usage[] = "ln [OPTION] TARGET... LINK_NAME|DIRECTORY\n\n"
"Create a link named LINK_NAME or DIRECTORY to the specified TARGET\n\n"
"Options:\n"
"\t-s\tmake symbolic links instead of hard links\n"
"\t-f\tremove existing destination files\n";
static int symlinkFlag = FALSE;
static int removeoldFlag = FALSE;
static const char *destName;
extern int ln_main(int argc, char **argv)
{
int status;
char newdestName[NAME_MAX];
static char* linkName;
if (argc < 3) {
usage (ln_usage);
@@ -69,30 +67,27 @@ extern int ln_main(int argc, char **argv)
}
destName = argv[argc - 1];
linkName = argv[argc - 1];
if ((argc > 3) && !(isDirectory(destName))) {
fprintf(stderr, "%s: not a directory\n", destName);
if ((argc > 3) && !(isDirectory(linkName))) {
fprintf(stderr, "%s: not a directory\n", linkName);
exit (FALSE);
}
while (argc-- >= 2) {
strcpy(newdestName, destName);
strcat(newdestName, (*argv)+(strlen(*(++argv))));
if (removeoldFlag==TRUE ) {
status = ( unlink(newdestName) && errno != ENOENT );
status = ( unlink(linkName) && errno != ENOENT );
if ( status != 0 ) {
perror(newdestName);
perror(linkName);
exit( FALSE);
}
}
if ( symlinkFlag==TRUE)
status = symlink(*argv, newdestName);
status = symlink(*argv, linkName);
else
status = link(*argv, newdestName);
status = link(*argv, linkName);
if ( status != 0 ) {
perror(newdestName);
perror(linkName);
exit( FALSE);
}
}
+40
View File
@@ -0,0 +1,40 @@
/*
* Mini logname implementation for busybox
*
* Copyright (C) 2000 Edward Betts <edward@debian.org>.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
static const char logname_usage[] = "logname\n\n"
"Print the name of the current user.\n";
extern int logname_main(int argc, char **argv) {
char *cp;
if (argc > 1) usage (logname_usage);
cp = getlogin ();
if (cp) {
puts (cp);
exit (TRUE);
}
fprintf (stderr, "%s: no login name\n", argv[0]);
exit (FALSE);
}
+58 -87
View File
@@ -40,11 +40,6 @@
* 1. requires lstat (BSD) - how do you do it without?
*/
//#define FEATURE_USERNAME /* show username/groupnames (libc6 uses NSS) */
#define FEATURE_TIMESTAMPS /* show file timestamps */
#define FEATURE_AUTOWIDTH /* calculate terminal & column widths */
#define FEATURE_FILETYPECHAR /* enable -p and -F */
#define TERMINAL_WIDTH 80 /* use 79 if your terminal has linefold bug */
#define COLUMN_WIDTH 14 /* default if AUTOWIDTH not defined */
#define COLUMN_GAP 2 /* includes the file type char, if present */
@@ -64,17 +59,13 @@
#include <dirent.h>
#include <errno.h>
#include <stdio.h>
#ifdef FEATURE_USERNAME
#include <pwd.h>
#include <grp.h>
#endif
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
#include <time.h>
#endif
#define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
#define TYPECHAR(mode) ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)])
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
#define APPCHAR(mode) ("\0|\0\0/\0\0\0\0\0@\0=\0\0\0" [TYPEINDEX(mode)])
#endif
@@ -83,27 +74,6 @@
#define MINOR(dev) ((dev)&0xff)
#endif
#define MODE1 "rwxrwxrwx"
#define MODE0 "---------"
#define SMODE1 "..s..s..t"
#define SMODE0 "..S..S..T"
/* The 9 mode bits to test */
static const mode_t MBIT[] = {
S_IRUSR, S_IWUSR, S_IXUSR,
S_IRGRP, S_IWGRP, S_IXGRP,
S_IROTH, S_IWOTH, S_IXOTH
};
/* The special bits. If set, display SMODE0/1 instead of MODE0/1 */
static const mode_t SBIT[] = {
0, 0, S_ISUID,
0, 0, S_ISGID,
0, 0, S_ISVTX
};
#define FMT_AUTO 0
#define FMT_LONG 1 /* one record per line, extended info */
#define FMT_SINGLE 2 /* one record per line */
@@ -128,14 +98,14 @@ static unsigned char display_fmt = FMT_AUTO;
static unsigned short opts = 0;
static unsigned short column = 0;
#ifdef FEATURE_AUTOWIDTH
#ifdef BB_FEATURE_AUTOWIDTH
static unsigned short terminal_width = 0, column_width = 0;
#else
#define terminal_width TERMINAL_WIDTH
#define column_width COLUMN_WIDTH
#endif
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
static unsigned char time_fmt = TIME_MOD;
#endif
@@ -188,7 +158,7 @@ static void tab(short col)
#undef nspaces
}
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
static char append_char(mode_t mode)
{
if (!(opts & DISP_FTYPE))
@@ -206,55 +176,55 @@ static char append_char(mode_t mode)
**
**/
static void list_single(const char *name, struct stat *info)
static void list_single(const char *name, struct stat *info, const char *fullname)
{
char scratch[PATH_MAX];
short len = strlen(name);
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
char append = append_char(info->st_mode);
#endif
if (display_fmt == FMT_LONG) {
mode_t mode = info->st_mode;
int i;
scratch[0] = TYPECHAR(mode);
for (i=0; i<9; i++)
if (mode & SBIT[i])
scratch[i+1] = (mode & MBIT[i])
? SMODE1[i]
: SMODE0[i];
else
scratch[i+1] = (mode & MBIT[i])
? MODE1[i]
: MODE0[i];
newline();
wr(scratch, 10);
wr(modeString(mode), 10);
column=10;
writenum((long)info->st_nlink,(short)4);
writenum((long)info->st_nlink,(short)5);
fputs(" ", stdout);
#ifdef FEATURE_USERNAME
#ifdef BB_FEATURE_LS_USERNAME
if (!(opts & DISP_NUMERIC)) {
struct passwd *pw = getpwuid(info->st_uid);
if (pw)
fputs(pw->pw_name, stdout);
else
writenum((long)info->st_uid,(short)0);
memset ( scratch, 0, sizeof (scratch));
my_getpwuid( scratch, info->st_uid);
if (*scratch) {
fputs(scratch, stdout);
if ( strlen( scratch) <= 8 )
wr(" ", 8-strlen( scratch));
}
else {
writenum((long) info->st_uid,(short)8);
fputs(" ", stdout);
}
} else
#endif
writenum((long)info->st_uid,(short)0);
tab(24);
#ifdef FEATURE_USERNAME
{
writenum((long) info->st_uid,(short)8);
fputs(" ", stdout);
}
#ifdef BB_FEATURE_LS_USERNAME
if (!(opts & DISP_NUMERIC)) {
struct group *gr = getgrgid(info->st_gid);
if (gr)
fputs(gr->gr_name, stdout);
else
writenum((long)info->st_gid,(short)0);
memset ( scratch, 0, sizeof (scratch));
my_getgrgid( scratch, info->st_gid);
if (*scratch) {
fputs(scratch, stdout);
if ( strlen( scratch) <= 8 )
wr(" ", 8-strlen( scratch));
}
else
writenum((long) info->st_gid,(short)8);
} else
#endif
writenum((long)info->st_gid,(short)0);
tab(33);
writenum((long) info->st_gid,(short)8);
//tab(26);
if (S_ISBLK(mode) || S_ISCHR(mode)) {
writenum((long)MAJOR(info->st_rdev),(short)3);
fputs(", ", stdout);
@@ -263,7 +233,8 @@ static void list_single(const char *name, struct stat *info)
else
writenum((long)info->st_size,(short)8);
fputs(" ", stdout);
#ifdef FEATURE_TIMESTAMPS
//tab(32);
#ifdef BB_FEATURE_LS_TIMESTAMPS
{
time_t cal;
char *string;
@@ -297,12 +268,12 @@ static void list_single(const char *name, struct stat *info)
wr(name, len);
if (S_ISLNK(mode)) {
wr(" -> ", 4);
len = readlink(name, scratch, sizeof scratch);
len = readlink(fullname, scratch, sizeof scratch);
if (len > 0) fwrite(scratch, 1, len, stdout);
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
/* show type of destination */
if (opts & DISP_FTYPE) {
if (!stat(name, info)) {
if (!stat(fullname, info)) {
append = append_char(info->st_mode);
if (append)
fputc(append, stdout);
@@ -310,7 +281,7 @@ static void list_single(const char *name, struct stat *info)
}
#endif
}
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
else if (append)
wr(&append, 1);
#endif
@@ -324,7 +295,7 @@ static void list_single(const char *name, struct stat *info)
newline();
else {
if (nexttab + column_width > terminal_width
#ifndef FEATURE_AUTOWIDTH
#ifndef BB_FEATURE_AUTOWIDTH
|| nexttab + len >= terminal_width
#endif
)
@@ -333,7 +304,7 @@ static void list_single(const char *name, struct stat *info)
tab(nexttab);
}
/* work out where next column starts */
#ifdef FEATURE_AUTOWIDTH
#ifdef BB_FEATURE_AUTOWIDTH
/* we know the calculated width is big enough */
nexttab = column + column_width + COLUMN_GAP;
#else
@@ -346,7 +317,7 @@ static void list_single(const char *name, struct stat *info)
/* now write the data */
wr(name, len);
column = column + len;
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
if (append)
wr(&append, 1), column++;
#endif
@@ -372,7 +343,7 @@ static int list_item(const char *name)
if (!S_ISDIR(info.st_mode) ||
(opts & DIR_NOLIST)) {
list_single(name, &info);
list_single(name, &info, name);
return 0;
}
@@ -387,7 +358,7 @@ static int list_item(const char *name)
dir = opendir(name);
if (!dir) goto listerr;
#ifdef FEATURE_AUTOWIDTH
#ifdef BB_FEATURE_AUTOWIDTH
column_width = 0;
while ((entry = readdir(dir)) != NULL) {
short w = strlen(entry->d_name);
@@ -424,7 +395,7 @@ static int list_item(const char *name)
strcpy(fnend, entry->d_name);
if (lstat(fullname, &info))
goto direrr; /* (shouldn't fail) */
list_single(entry->d_name, &info);
list_single(entry->d_name, &info, fullname);
}
closedir(dir);
return 0;
@@ -438,22 +409,22 @@ listerr:
}
static const char ls_usage[] = "ls [-1a"
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
"c"
#endif
"d"
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
"e"
#endif
"ln"
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
"p"
#endif
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
"u"
#endif
"xAC"
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
"F"
#endif
#ifdef FEATURE_RECURSIVE
@@ -486,7 +457,7 @@ ls_main(int argc, char * * argv)
case '1': display_fmt = FMT_SINGLE; break;
case 'x': display_fmt = FMT_ROWS; break;
case 'C': display_fmt = FMT_COLUMNS; break;
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
case 'p': opts |= DISP_FTYPE; break;
case 'F': opts |= DISP_FTYPE|DISP_EXEC; break;
#endif
@@ -497,7 +468,7 @@ ls_main(int argc, char * * argv)
#ifdef FEATURE_RECURSIVE
case 'R': opts |= DIR_RECURSE; break;
#endif
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
case 'u': time_fmt = TIME_ACCESS; break;
case 'c': time_fmt = TIME_CHANGE; break;
case 'e': opts |= DISP_FULLTIME; break;
@@ -510,10 +481,10 @@ ls_main(int argc, char * * argv)
/* choose a display format */
if (display_fmt == FMT_AUTO)
display_fmt = isatty(STDOUT_FILENO) ? FMT_COLUMNS : FMT_SINGLE;
display_fmt = isatty(fileno(stdout)) ? FMT_COLUMNS : FMT_SINGLE;
if (argi < argc - 1)
opts |= DISP_DIRNAME; /* 2 or more items? label directories */
#ifdef FEATURE_AUTOWIDTH
#ifdef BB_FEATURE_AUTOWIDTH
/* could add a -w option and/or TIOCGWINSZ call */
if (terminal_width < 1) terminal_width = TERMINAL_WIDTH;
+17 -11
View File
@@ -26,14 +26,15 @@
#include <errno.h>
#include <sys/param.h>
static const char mkdir_usage[] = "Usage: mkdir [OPTION] DIRECTORY...\n"
static const char mkdir_usage[] = "Usage: mkdir [OPTION] DIRECTORY...\n\n"
"Create the DIRECTORY(ies), if they do not already exist\n\n"
"-m\tset permission mode (as in chmod), not rwxrwxrwx - umask\n"
"-p\tno error if existing, make parent directories as needed\n";
"Options:\n"
"\t-m\tset permission mode (as in chmod), not rwxrwxrwx - umask\n"
"\t-p\tno error if existing, make parent directories as needed\n";
static int parentFlag = FALSE;
static mode_t mode = 777;
static mode_t mode = 0777;
extern int mkdir_main(int argc, char **argv)
@@ -79,16 +80,21 @@ extern int mkdir_main(int argc, char **argv)
while (argc > 0) {
int status;
struct stat statBuf;
status=stat(*argv, &statBuf);
if (status != -1 && status != ENOENT ) {
fprintf(stderr, "%s: File exists\n", *argv);
char buf[NAME_MAX];
strcpy (buf, *argv);
status=stat(buf, &statBuf);
if (parentFlag == FALSE && status != -1 && status != ENOENT ) {
fprintf(stderr, "%s: File exists\n", buf);
exit( FALSE);
}
if (parentFlag == TRUE)
createPath(*argv, mode);
if (parentFlag == TRUE) {
strcat( buf, "/");
createPath(buf, mode);
}
else {
if (mkdir (*argv, mode) != 0) {
perror(*argv);
if (mkdir (buf, mode) != 0 && parentFlag == FALSE) {
perror(buf);
exit( FALSE);
}
}
+61
View File
@@ -0,0 +1,61 @@
/*
* Mini mkfifo implementation for busybox
*
* Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
static const char mkfifo_usage[] = "mkfifo [OPTIONS] name\n\n"
"Create the named fifo\n\n"
"Options:\n"
"\t-m\tcreate the fifo with the specified mode; default = a=rw-umask\n";
extern int mkfifo_main(int argc, char **argv)
{
char *thisarg;
mode_t mode = 0666;
argc--;
argv++;
/* Parse any options */
while (argc > 1) {
if (**argv != '-') usage(mkfifo_usage);
thisarg = *argv; thisarg++;
switch (*thisarg) {
case 'm':
argc--; argv++;
parse_mode(*argv, &mode);
break;
default:
usage (mkfifo_usage);
}
argc--; argv++;
}
if (argc < 1) usage (mkfifo_usage);
if (mkfifo(*argv, mode) < 0) {
perror("mkfifo");
exit(255);
} else {
exit(TRUE);
}
}
+6 -3
View File
@@ -27,9 +27,9 @@
#include <fcntl.h>
#include <unistd.h>
static const char mknod_usage[] = "mknod file b|c|u|p major minor\n"
"\tMake special files.\n"
"\n"
static const char mknod_usage[] = "mknod NAME TYPE MAJOR MINOR\n\n"
"Make block or character special files.\n\n"
"TYPEs include:\n"
"\tb:\tMake a block (buffered) device.\n"
"\tc or u:\tMake a character (un-buffered) device.\n"
"\tp:\tMake a named pipe. Major and minor are ignored for named pipes.\n";
@@ -40,6 +40,9 @@ mknod_main(int argc, char** argv)
mode_t mode = 0;
dev_t dev = 0;
if ( argc != 5 || **(argv+1) == '-' ) {
usage (mknod_usage);
}
switch(argv[2][0]) {
case 'c':
case 'u':
+52 -20
View File
@@ -27,22 +27,61 @@
#include <utime.h>
#include <dirent.h>
static const char mv_usage[] = "mv SOURCE DEST\n"
" or: mv SOURCE... DIRECTORY\n"
" or: mv SOURCE... DIRECTORY\n\n"
"Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.\n";
static const char *srcName;
static const char *destName;
static const char *skipName;
static int dirFlag = FALSE;
static int destDirFlag = FALSE;
static int srcDirFlag = FALSE;
static int fileAction(const char *fileName, struct stat* statbuf)
{
char newdestName[NAME_MAX];
char* newsrcName = NULL;
strcpy(newdestName, destName);
if ( srcDirFlag == TRUE ) {
strcat(newdestName, strstr(fileName, srcName) + strlen(srcName));
}
if (destDirFlag==TRUE && srcDirFlag == FALSE) {
if (newdestName[strlen(newdestName)-1] != '/' ) {
strcat(newdestName, "/");
}
newsrcName = strrchr(srcName, '/');
if (newsrcName && *newsrcName != '\0')
strcat(newdestName, newsrcName);
else
strcat(newdestName, srcName);
}
return (copyFile(fileName, newdestName, TRUE, TRUE));
}
static int rmfileAction(const char *fileName, struct stat* statbuf)
{
if (unlink( fileName) < 0 ) {
perror( fileName);
return ( FALSE);
}
return ( TRUE);
}
static int rmdirAction(const char *fileName, struct stat* statbuf)
{
if (rmdir( fileName) < 0 ) {
perror( fileName);
return ( FALSE);
}
return ( TRUE);
}
extern int mv_main(int argc, char **argv)
{
char newdestName[NAME_MAX];
if (argc < 3) {
usage (mv_usage);
}
@@ -50,29 +89,22 @@ extern int mv_main(int argc, char **argv)
argv++;
destName = argv[argc - 1];
dirFlag = isDirectory(destName);
destDirFlag = isDirectory(destName);
if ((argc > 3) && dirFlag==FALSE) {
if ((argc > 3) && destDirFlag==FALSE) {
fprintf(stderr, "%s: not a directory\n", destName);
exit (FALSE);
}
while (argc-- > 1) {
srcName = *(argv++);
skipName = strrchr(srcName, '/');
if (skipName)
skipName++;
strcpy(newdestName, destName);
if (dirFlag==TRUE) {
strcat(newdestName, "/");
if ( skipName != NULL)
strcat(newdestName, strstr(srcName, skipName));
}
if (copyFile(srcName, newdestName, FALSE, FALSE) == FALSE) {
srcDirFlag = isDirectory(srcName);
if (recursiveAction(srcName, TRUE, TRUE, FALSE,
fileAction, fileAction) == FALSE) {
exit( FALSE);
}
if (unlink (srcName) < 0) {
perror (srcName);
if (recursiveAction(srcName, TRUE, TRUE, TRUE,
rmfileAction, rmdirAction) == FALSE) {
exit( FALSE);
}
}
+15 -6
View File
@@ -26,11 +26,13 @@
#include <time.h>
#include <utime.h>
#include <dirent.h>
#include <errno.h>
static const char* rm_usage = "rm [OPTION]... FILE...\n"
static const char* rm_usage = "rm [OPTION]... FILE...\n\n"
"Remove (unlink) the FILE(s).\n\n"
"\t-f\tremove existing destinations, never prompt\n"
"\t-r\tremove the contents of directories recursively\n";
"Options:\n"
"\t-f\t\tremove existing destinations, never prompt\n"
"\t-r or -R\tremove the contents of directories recursively\n";
static int recursiveFlag = FALSE;
@@ -58,6 +60,7 @@ static int dirAction(const char *fileName, struct stat* statbuf)
extern int rm_main(int argc, char **argv)
{
struct stat statbuf;
if (argc < 2) {
usage( rm_usage);
@@ -69,6 +72,7 @@ extern int rm_main(int argc, char **argv)
while (**argv == '-') {
while (*++(*argv))
switch (**argv) {
case 'R':
case 'r':
recursiveFlag = TRUE;
break;
@@ -84,9 +88,14 @@ extern int rm_main(int argc, char **argv)
while (argc-- > 0) {
srcName = *(argv++);
if (recursiveAction( srcName, recursiveFlag, TRUE, TRUE,
fileAction, dirAction) == FALSE) {
exit( FALSE);
if (forceFlag == TRUE && lstat(srcName, &statbuf) != 0 && errno == ENOENT) {
/* do not reports errors for non-existent files if -f, just skip them */
}
else {
if (recursiveAction( srcName, recursiveFlag, FALSE,
TRUE, fileAction, dirAction) == FALSE) {
exit( FALSE);
}
}
}
exit( TRUE);
+1 -1
View File
@@ -29,7 +29,7 @@
extern int rmdir_main(int argc, char **argv)
{
if ( argc==1 || **(argv+1) == '-' ) {
usage( "rmdir [OPTION]... DIRECTORY...\nRemove the DIRECTORY(ies), if they are empty.");
usage( "rmdir [OPTION]... DIRECTORY...\n\nRemove the DIRECTORY(ies), if they are empty.\n");
}
while (--argc > 0) {
+2 -2
View File
@@ -23,8 +23,8 @@
#include "internal.h"
#include <stdio.h>
const char sleep_usage[] = " NUMBER\n"
"Pause for NUMBER seconds.\n";
const char sleep_usage[] = "sleep N\n\n"
"Pause for N seconds.\n";
extern int
sleep_main(int argc, char * * argv)
+312
View File
@@ -0,0 +1,312 @@
/*
* Mini sort implementation for busybox
*
*
* Copyright (C) 1999 by Lineo, inc.
* Written by John Beppu <beppu@lineo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <sys/types.h>
#include <fcntl.h>
#include <dirent.h>
#include <stdio.h>
#include <errno.h>
static const char sort_usage[] =
"Usage: sort [OPTION]... [FILE]...\n\n"
;
/* typedefs _______________________________________________________________ */
/* line node */
typedef struct Line {
char *data; /* line data */
struct Line *next; /* pointer to next line node */
} Line;
/* singly-linked list of lines */
typedef struct {
int len; /* number of Lines */
Line **sorted; /* array fed to qsort */
Line *head; /* head of List */
Line *current; /* current Line */
} List;
/* comparison function */
typedef int (Compare)(const void *, const void *);
/* methods ________________________________________________________________ */
static const int max = 1024;
/* mallocate Line */
static Line *
line_alloc()
{
Line *self;
self = malloc(1 * sizeof(Line));
return self;
}
/* Initialize Line with string */
static Line *
line_init(Line *self, const char *string)
{
self->data = malloc((strlen(string) + 1) * sizeof(char));
if (self->data == NULL) { return NULL; }
strcpy(self->data, string);
self->next = NULL;
return self;
}
/* Construct Line from FILE* */
static Line *
line_newFromFile(FILE *src)
{
char buffer[max];
Line *self;
if (fgets(buffer, max, src)) {
self = line_alloc();
if (self == NULL) { return NULL; }
line_init(self, buffer);
return self;
}
return NULL;
}
/* Line destructor */
static Line *
line_release(Line *self)
{
if (self->data) {
free(self->data);
free(self);
}
return self;
}
/* Comparison */
/* ascii order */
static int
compare_ascii(const void *a, const void *b)
{
Line **doh;
Line *x, *y;
doh = (Line **) a;
x = *doh;
doh = (Line **) b;
y = *doh;
// fprintf(stdout, "> %p: %s< %p: %s", x, x->data, y, y->data);
return strcmp(x->data, y->data);
}
/* numeric order */
static int
compare_numeric(const void *a, const void *b)
{
Line **doh;
Line *x, *y;
int xint, yint;
doh = (Line **) a;
x = *doh;
doh = (Line **) b;
y = *doh;
xint = strtoul(x->data, NULL, 10);
yint = strtoul(y->data, NULL, 10);
return (xint - yint);
}
/* List */
/* */
static List *
list_init(List *self)
{
self->len = 0;
self->sorted = NULL;
self->head = NULL;
self->current = NULL;
return self;
}
/* for simplicity, the List gains ownership of the line */
static List *
list_insert(List *self, Line *line)
{
if (line == NULL) { return NULL; }
/* first insertion */
if (self->head == NULL) {
self->head = line;
self->current = line;
/* all subsequent insertions */
} else {
self->current->next = line;
self->current = line;
}
self->len++;
return self;
}
/* order the list according to compare() */
static List *
list_sort(List *self, Compare *compare)
{
int i;
Line *line;
/* mallocate array of Line*s */
self->sorted = (Line **) malloc(self->len * sizeof(Line*));
if (self->sorted == NULL) { return NULL; }
/* fill array w/ List's contents */
i = 0;
line = self->head;
while (line) {
self->sorted[i++] = line;
line = line->next;
}
/* apply qsort */
qsort(self->sorted, self->len, sizeof(Line*), compare);
return self;
}
/* precondition: list must be sorted */
static List *
list_writeToFile(List *self, FILE* dst)
{
int i;
Line **line = self->sorted;
if (self->sorted == NULL) { return NULL; }
for (i = 0; i < self->len; i++) {
fprintf(dst, "%s", line[i]->data);
}
return self;
}
/* deallocate */
static void
list_release(List *self)
{
Line *i;
Line *die;
i = self->head;
while (i) {
die = i;
i = die->next;
line_release(die);
}
}
/*
* I need a list
* to insert lines into
* then I need to sort this list
* and finally print it
*/
int
sort_main(int argc, char **argv)
{
int i;
char opt;
List list;
Line *l;
Compare *compare;
/* init */
compare = compare_ascii;
list_init(&list);
/* parse argv[] */
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
opt = argv[i][1];
switch (opt) {
case 'g':
/* what's the diff between -g && -n? */
compare = compare_numeric;
break;
case 'h':
usage(sort_usage);
break;
case 'n':
/* what's the diff between -g && -n? */
compare = compare_numeric;
break;
case 'r':
/* reverse */
break;
default:
fprintf(stderr, "sort: invalid option -- %c\n", opt);
usage(sort_usage);
}
} else {
break;
}
}
/* this could be factored better */
/* work w/ stdin */
if (i >= argc) {
while ( (l = line_newFromFile(stdin))) {
list_insert(&list, l);
}
list_sort(&list, compare);
list_writeToFile(&list, stdout);
list_release(&list);
/* work w/ what's left in argv[] */
} else {
FILE *src;
for ( ; i < argc; i++) {
src = fopen(argv[i], "r");
if (src == NULL) { break; }
while ( (l = line_newFromFile(src))) {
list_insert(&list, l);
}
fclose(src);
}
list_sort(&list, compare);
list_writeToFile(&list, stdout);
list_release(&list);
}
exit(0);
}
/* $Id: sort.c,v 1.8 1999/12/23 22:46:10 beppu Exp $ */
+1 -1
View File
@@ -27,7 +27,7 @@ extern int
sync_main(int argc, char * * argv)
{
if ( argc>1 && **(argv+1) == '-' ) {
usage( "sync\nWrite all buffered filesystem blocks to disk.\n");
usage( "sync\n\nWrite all buffered filesystem blocks to disk.\n");
}
exit( sync());
}
+910
View File
@@ -0,0 +1,910 @@
/* tail -- output the last part of file(s)
Copyright (C) 89, 90, 91, 95, 1996 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Original version by Paul Rubin <phr@ocf.berkeley.edu>.
Extensions by David MacKenzie <djm@gnu.ai.mit.edu>.
tail -f for multiple files by Ian Lance Taylor <ian@airs.com>.
Rewrote the option parser, removed locales support,
and generally busyboxed, Erik Andersen <andersen@lineo.com>
*/
#include "internal.h"
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <ctype.h>
/* Disable assertions. Some systems have broken assert macros. */
#define NDEBUG 1
static void error(int i, int errnum, char* fmt, ...)
{
va_list arguments;
va_start(arguments, fmt);
vfprintf(stderr, fmt, arguments);
fprintf(stderr, "\n%s\n", strerror( errnum));
va_end(arguments);
exit(i);
}
#define XWRITE(fd, buffer, n_bytes) \
do \
{ \
assert ((fd) == 1); \
assert ((n_bytes) >= 0); \
if (n_bytes > 0 && fwrite ((buffer), 1, (n_bytes), stdout) == 0) \
error (EXIT_FAILURE, errno, "write error"); \
} \
while (0)
/* Number of items to tail. */
#define DEFAULT_N_LINES 10
/* Size of atomic reads. */
#ifndef BUFSIZ
#define BUFSIZ (512 * 8)
#endif
/* If nonzero, interpret the numeric argument as the number of lines.
Otherwise, interpret it as the number of bytes. */
static int count_lines;
/* If nonzero, read from the end of one file until killed. */
static int forever;
/* If nonzero, read from the end of multiple files until killed. */
static int forever_multiple;
/* Array of file descriptors if forever_multiple is 1. */
static int *file_descs;
/* Array of file sizes if forever_multiple is 1. */
static off_t *file_sizes;
/* If nonzero, count from start of file instead of end. */
static int from_start;
/* If nonzero, print filename headers. */
static int print_headers;
/* When to print the filename banners. */
enum header_mode
{
multiple_files, always, never
};
char *xmalloc ();
/* The name this program was run with. */
char *program_name;
/* Nonzero if we have ever read standard input. */
static int have_read_stdin;
static const char tail_usage[] =
"tail [OPTION]... [FILE]...\n\
\n\
Print last 10 lines of each FILE to standard output.\n\
With more than one FILE, precede each with a header giving the file name.\n\
With no FILE, or when FILE is -, read standard input.\n\
\n\
-c=N[kbm] output the last N bytes\n\
-f output appended data as the file grows\n\
-n=N output the last N lines, instead of last 10\n\
-q never output headers giving file names\n\
-v always output headers giving file names\n\
--help display this help and exit\n\
\n\
If the first character of N (bytes or lines) is a `+', output begins with \n\
the Nth item from the start of each file, otherwise, print the last N items\n\
in the file. N bytes may be suffixed by k (x1024), b (x512), or m (1024^2).\n\n";
static void
write_header (const char *filename, const char *comment)
{
static int first_file = 1;
printf ("%s==> %s%s%s <==\n", (first_file ? "" : "\n"), filename,
(comment ? ": " : ""),
(comment ? comment : ""));
first_file = 0;
}
/* Print the last N_LINES lines from the end of file FD.
Go backward through the file, reading `BUFSIZ' bytes at a time (except
probably the first), until we hit the start of the file or have
read NUMBER newlines.
POS starts out as the length of the file (the offset of the last
byte of the file + 1).
Return 0 if successful, 1 if an error occurred. */
static int
file_lines (const char *filename, int fd, long int n_lines, off_t pos)
{
char buffer[BUFSIZ];
int bytes_read;
int i; /* Index into `buffer' for scanning. */
if (n_lines == 0)
return 0;
/* Set `bytes_read' to the size of the last, probably partial, buffer;
0 < `bytes_read' <= `BUFSIZ'. */
bytes_read = pos % BUFSIZ;
if (bytes_read == 0)
bytes_read = BUFSIZ;
/* Make `pos' a multiple of `BUFSIZ' (0 if the file is short), so that all
reads will be on block boundaries, which might increase efficiency. */
pos -= bytes_read;
lseek (fd, pos, SEEK_SET);
bytes_read = fullRead (fd, buffer, bytes_read);
if (bytes_read == -1)
{
error (0, errno, "%s", filename);
return 1;
}
/* Count the incomplete line on files that don't end with a newline. */
if (bytes_read && buffer[bytes_read - 1] != '\n')
--n_lines;
do
{
/* Scan backward, counting the newlines in this bufferfull. */
for (i = bytes_read - 1; i >= 0; i--)
{
/* Have we counted the requested number of newlines yet? */
if (buffer[i] == '\n' && n_lines-- == 0)
{
/* If this newline wasn't the last character in the buffer,
print the text after it. */
if (i != bytes_read - 1)
XWRITE (STDOUT_FILENO, &buffer[i + 1], bytes_read - (i + 1));
return 0;
}
}
/* Not enough newlines in that bufferfull. */
if (pos == 0)
{
/* Not enough lines in the file; print the entire file. */
lseek (fd, (off_t) 0, SEEK_SET);
return 0;
}
pos -= BUFSIZ;
lseek (fd, pos, SEEK_SET);
}
while ((bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0);
if (bytes_read == -1)
{
error (0, errno, "%s", filename);
return 1;
}
return 0;
}
/* Print the last N_LINES lines from the end of the standard input,
open for reading as pipe FD.
Buffer the text as a linked list of LBUFFERs, adding them as needed.
Return 0 if successful, 1 if an error occured. */
static int
pipe_lines (const char *filename, int fd, long int n_lines)
{
struct linebuffer
{
int nbytes, nlines;
char buffer[BUFSIZ];
struct linebuffer *next;
};
typedef struct linebuffer LBUFFER;
LBUFFER *first, *last, *tmp;
int i; /* Index into buffers. */
int total_lines = 0; /* Total number of newlines in all buffers. */
int errors = 0;
first = last = (LBUFFER *) xmalloc (sizeof (LBUFFER));
first->nbytes = first->nlines = 0;
first->next = NULL;
tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
/* Input is always read into a fresh buffer. */
while ((tmp->nbytes = fullRead (fd, tmp->buffer, BUFSIZ)) > 0)
{
tmp->nlines = 0;
tmp->next = NULL;
/* Count the number of newlines just read. */
for (i = 0; i < tmp->nbytes; i++)
if (tmp->buffer[i] == '\n')
++tmp->nlines;
total_lines += tmp->nlines;
/* If there is enough room in the last buffer read, just append the new
one to it. This is because when reading from a pipe, `nbytes' can
often be very small. */
if (tmp->nbytes + last->nbytes < BUFSIZ)
{
memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
last->nbytes += tmp->nbytes;
last->nlines += tmp->nlines;
}
else
{
/* If there's not enough room, link the new buffer onto the end of
the list, then either free up the oldest buffer for the next
read if that would leave enough lines, or else malloc a new one.
Some compaction mechanism is possible but probably not
worthwhile. */
last = last->next = tmp;
if (total_lines - first->nlines > n_lines)
{
tmp = first;
total_lines -= first->nlines;
first = first->next;
}
else
tmp = (LBUFFER *) xmalloc (sizeof (LBUFFER));
}
}
if (tmp->nbytes == -1)
{
error (0, errno, "%s", filename);
errors = 1;
free ((char *) tmp);
goto free_lbuffers;
}
free ((char *) tmp);
/* This prevents a core dump when the pipe contains no newlines. */
if (n_lines == 0)
goto free_lbuffers;
/* Count the incomplete line on files that don't end with a newline. */
if (last->buffer[last->nbytes - 1] != '\n')
{
++last->nlines;
++total_lines;
}
/* Run through the list, printing lines. First, skip over unneeded
buffers. */
for (tmp = first; total_lines - tmp->nlines > n_lines; tmp = tmp->next)
total_lines -= tmp->nlines;
/* Find the correct beginning, then print the rest of the file. */
if (total_lines > n_lines)
{
char *cp;
/* Skip `total_lines' - `n_lines' newlines. We made sure that
`total_lines' - `n_lines' <= `tmp->nlines'. */
cp = tmp->buffer;
for (i = total_lines - n_lines; i; --i)
while (*cp++ != '\n')
/* Do nothing. */ ;
i = cp - tmp->buffer;
}
else
i = 0;
XWRITE (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
for (tmp = tmp->next; tmp; tmp = tmp->next)
XWRITE (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
free_lbuffers:
while (first)
{
tmp = first->next;
free ((char *) first);
first = tmp;
}
return errors;
}
/* Print the last N_BYTES characters from the end of pipe FD.
This is a stripped down version of pipe_lines.
Return 0 if successful, 1 if an error occurred. */
static int
pipe_bytes (const char *filename, int fd, off_t n_bytes)
{
struct charbuffer
{
int nbytes;
char buffer[BUFSIZ];
struct charbuffer *next;
};
typedef struct charbuffer CBUFFER;
CBUFFER *first, *last, *tmp;
int i; /* Index into buffers. */
int total_bytes = 0; /* Total characters in all buffers. */
int errors = 0;
first = last = (CBUFFER *) xmalloc (sizeof (CBUFFER));
first->nbytes = 0;
first->next = NULL;
tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
/* Input is always read into a fresh buffer. */
while ((tmp->nbytes = fullRead (fd, tmp->buffer, BUFSIZ)) > 0)
{
tmp->next = NULL;
total_bytes += tmp->nbytes;
/* If there is enough room in the last buffer read, just append the new
one to it. This is because when reading from a pipe, `nbytes' can
often be very small. */
if (tmp->nbytes + last->nbytes < BUFSIZ)
{
memcpy (&last->buffer[last->nbytes], tmp->buffer, tmp->nbytes);
last->nbytes += tmp->nbytes;
}
else
{
/* If there's not enough room, link the new buffer onto the end of
the list, then either free up the oldest buffer for the next
read if that would leave enough characters, or else malloc a new
one. Some compaction mechanism is possible but probably not
worthwhile. */
last = last->next = tmp;
if (total_bytes - first->nbytes > n_bytes)
{
tmp = first;
total_bytes -= first->nbytes;
first = first->next;
}
else
{
tmp = (CBUFFER *) xmalloc (sizeof (CBUFFER));
}
}
}
if (tmp->nbytes == -1)
{
error (0, errno, "%s", filename);
errors = 1;
free ((char *) tmp);
goto free_cbuffers;
}
free ((char *) tmp);
/* Run through the list, printing characters. First, skip over unneeded
buffers. */
for (tmp = first; total_bytes - tmp->nbytes > n_bytes; tmp = tmp->next)
total_bytes -= tmp->nbytes;
/* Find the correct beginning, then print the rest of the file.
We made sure that `total_bytes' - `n_bytes' <= `tmp->nbytes'. */
if (total_bytes > n_bytes)
i = total_bytes - n_bytes;
else
i = 0;
XWRITE (STDOUT_FILENO, &tmp->buffer[i], tmp->nbytes - i);
for (tmp = tmp->next; tmp; tmp = tmp->next)
XWRITE (STDOUT_FILENO, tmp->buffer, tmp->nbytes);
free_cbuffers:
while (first)
{
tmp = first->next;
free ((char *) first);
first = tmp;
}
return errors;
}
/* Skip N_BYTES characters from the start of pipe FD, and print
any extra characters that were read beyond that.
Return 1 on error, 0 if ok. */
static int
start_bytes (const char *filename, int fd, off_t n_bytes)
{
char buffer[BUFSIZ];
int bytes_read = 0;
while (n_bytes > 0 && (bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0)
n_bytes -= bytes_read;
if (bytes_read == -1)
{
error (0, errno, "%s", filename);
return 1;
}
else if (n_bytes < 0)
XWRITE (STDOUT_FILENO, &buffer[bytes_read + n_bytes], -n_bytes);
return 0;
}
/* Skip N_LINES lines at the start of file or pipe FD, and print
any extra characters that were read beyond that.
Return 1 on error, 0 if ok. */
static int
start_lines (const char *filename, int fd, long int n_lines)
{
char buffer[BUFSIZ];
int bytes_read = 0;
int bytes_to_skip = 0;
while (n_lines && (bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0)
{
bytes_to_skip = 0;
while (bytes_to_skip < bytes_read)
if (buffer[bytes_to_skip++] == '\n' && --n_lines == 0)
break;
}
if (bytes_read == -1)
{
error (0, errno, "%s", filename);
return 1;
}
else if (bytes_to_skip < bytes_read)
{
XWRITE (STDOUT_FILENO, &buffer[bytes_to_skip],
bytes_read - bytes_to_skip);
}
return 0;
}
/* Display file FILENAME from the current position in FD to the end.
If `forever' is nonzero, keep reading from the end of the file
until killed. Return the number of bytes read from the file. */
static long
dump_remainder (const char *filename, int fd)
{
char buffer[BUFSIZ];
int bytes_read;
long total;
total = 0;
output:
while ((bytes_read = fullRead (fd, buffer, BUFSIZ)) > 0)
{
XWRITE (STDOUT_FILENO, buffer, bytes_read);
total += bytes_read;
}
if (bytes_read == -1)
error (EXIT_FAILURE, errno, "%s", filename);
if (forever)
{
fflush (stdout);
sleep (1);
goto output;
}
else
{
if (forever_multiple)
fflush (stdout);
}
return total;
}
/* Tail NFILES (>1) files forever until killed. The file names are in
NAMES. The open file descriptors are in `file_descs', and the size
at which we stopped tailing them is in `file_sizes'. We loop over
each of them, doing an fstat to see if they have changed size. If
none of them have changed size in one iteration, we sleep for a
second and try again. We do this until the user interrupts us. */
static void
tail_forever (char **names, int nfiles)
{
int last;
last = -1;
while (1)
{
int i;
int changed;
changed = 0;
for (i = 0; i < nfiles; i++)
{
struct stat stats;
if (file_descs[i] < 0)
continue;
if (fstat (file_descs[i], &stats) < 0)
{
error (0, errno, "%s", names[i]);
file_descs[i] = -1;
continue;
}
if (stats.st_size == file_sizes[i])
continue;
/* This file has changed size. Print out what we can, and
then keep looping. */
changed = 1;
if (stats.st_size < file_sizes[i])
{
write_header (names[i], "file truncated");
last = i;
lseek (file_descs[i], stats.st_size, SEEK_SET);
file_sizes[i] = stats.st_size;
continue;
}
if (i != last)
{
if (print_headers)
write_header (names[i], NULL);
last = i;
}
file_sizes[i] += dump_remainder (names[i], file_descs[i]);
}
/* If none of the files changed size, sleep. */
if (! changed)
sleep (1);
}
}
/* Output the last N_BYTES bytes of file FILENAME open for reading in FD.
Return 0 if successful, 1 if an error occurred. */
static int
tail_bytes (const char *filename, int fd, off_t n_bytes)
{
struct stat stats;
/* FIXME: resolve this like in dd.c. */
/* Use fstat instead of checking for errno == ESPIPE because
lseek doesn't work on some special files but doesn't return an
error, either. */
if (fstat (fd, &stats))
{
error (0, errno, "%s", filename);
return 1;
}
if (from_start)
{
if (S_ISREG (stats.st_mode))
lseek (fd, n_bytes, SEEK_CUR);
else if (start_bytes (filename, fd, n_bytes))
return 1;
dump_remainder (filename, fd);
}
else
{
if (S_ISREG (stats.st_mode))
{
off_t current_pos, end_pos;
size_t bytes_remaining;
if ((current_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
&& (end_pos = lseek (fd, (off_t) 0, SEEK_END)) != -1)
{
off_t diff;
/* Be careful here. The current position may actually be
beyond the end of the file. */
bytes_remaining = (diff = end_pos - current_pos) < 0 ? 0 : diff;
}
else
{
error (0, errno, "%s", filename);
return 1;
}
if (bytes_remaining <= n_bytes)
{
/* From the current position to end of file, there are no
more bytes than have been requested. So reposition the
file pointer to the incoming current position and print
everything after that. */
lseek (fd, current_pos, SEEK_SET);
}
else
{
/* There are more bytes remaining than were requested.
Back up. */
lseek (fd, -n_bytes, SEEK_END);
}
dump_remainder (filename, fd);
}
else
return pipe_bytes (filename, fd, n_bytes);
}
return 0;
}
/* Output the last N_LINES lines of file FILENAME open for reading in FD.
Return 0 if successful, 1 if an error occurred. */
static int
tail_lines (const char *filename, int fd, long int n_lines)
{
struct stat stats;
off_t length;
if (fstat (fd, &stats))
{
error (0, errno, "%s", filename);
return 1;
}
if (from_start)
{
if (start_lines (filename, fd, n_lines))
return 1;
dump_remainder (filename, fd);
}
else
{
/* Use file_lines only if FD refers to a regular file with
its file pointer positioned at beginning of file. */
/* FIXME: adding the lseek conjunct is a kludge.
Once there's a reasonable test suite, fix the true culprit:
file_lines. file_lines shouldn't presume that the input
file pointer is initially positioned to beginning of file. */
if (S_ISREG (stats.st_mode)
&& lseek (fd, (off_t) 0, SEEK_CUR) == (off_t) 0)
{
length = lseek (fd, (off_t) 0, SEEK_END);
if (length != 0 && file_lines (filename, fd, n_lines, length))
return 1;
dump_remainder (filename, fd);
}
else
return pipe_lines (filename, fd, n_lines);
}
return 0;
}
/* Display the last N_UNITS units of file FILENAME, open for reading
in FD.
Return 0 if successful, 1 if an error occurred. */
static int
tail (const char *filename, int fd, off_t n_units)
{
if (count_lines)
return tail_lines (filename, fd, (long) n_units);
else
return tail_bytes (filename, fd, n_units);
}
/* Display the last N_UNITS units of file FILENAME.
"-" for FILENAME means the standard input.
FILENUM is this file's index in the list of files the user gave.
Return 0 if successful, 1 if an error occurred. */
static int
tail_file (const char *filename, off_t n_units, int filenum)
{
int fd, errors;
struct stat stats;
if (!strcmp (filename, "-"))
{
have_read_stdin = 1;
filename = "standard input";
if (print_headers)
write_header (filename, NULL);
errors = tail (filename, 0, n_units);
if (forever_multiple)
{
if (fstat (0, &stats) < 0)
{
error (0, errno, "standard input");
errors = 1;
}
else if (!S_ISREG (stats.st_mode))
{
error (0, 0,
"standard input: cannot follow end of non-regular file");
errors = 1;
}
if (errors)
file_descs[filenum] = -1;
else
{
file_descs[filenum] = 0;
file_sizes[filenum] = stats.st_size;
}
}
}
else
{
/* Not standard input. */
fd = open (filename, O_RDONLY);
if (fd == -1)
{
if (forever_multiple)
file_descs[filenum] = -1;
error (0, errno, "%s", filename);
errors = 1;
}
else
{
if (print_headers)
write_header (filename, NULL);
errors = tail (filename, fd, n_units);
if (forever_multiple)
{
if (fstat (fd, &stats) < 0)
{
error (0, errno, "%s", filename);
errors = 1;
}
else if (!S_ISREG (stats.st_mode))
{
error (0, 0, "%s: cannot follow end of non-regular file",
filename);
errors = 1;
}
if (errors)
{
close (fd);
file_descs[filenum] = -1;
}
else
{
file_descs[filenum] = fd;
file_sizes[filenum] = stats.st_size;
}
}
else
{
if (close (fd))
{
error (0, errno, "%s", filename);
errors = 1;
}
}
}
}
return errors;
}
extern int
tail_main (int argc, char **argv)
{
int stopit = 0;
enum header_mode header_mode = multiple_files;
int exit_status = 0;
/* If from_start, the number of items to skip before printing; otherwise,
the number of items at the end of the file to print. Initially, -1
means the value has not been set. */
off_t n_units = -1;
int n_files;
char **file;
program_name = argv[0];
have_read_stdin = 0;
count_lines = 1;
forever = forever_multiple = from_start = print_headers = 0;
/* Parse any options */
//fprintf(stderr, "argc=%d, argv=%s\n", argc, *argv);
while (--argc > 0 && ( **(++argv) == '-' || **argv == '+' )) {
if (**argv == '+') {
from_start = 1;
}
stopit = 0;
while (stopit == 0 && *(++(*argv))) {
switch (**argv) {
case 'c':
count_lines = 0;
if (--argc < 1) {
usage(tail_usage);
}
n_units = getNum(*(++argv));
stopit = 1;
break;
case 'f':
forever = 1;
break;
case 'n':
count_lines = 1;
if (--argc < 1) {
usage(tail_usage);
}
n_units = atol(*(++argv));
stopit = 1;
break;
case 'q':
header_mode = never;
break;
case 'v':
header_mode = always;
break;
default:
usage (tail_usage);
}
}
}
if (n_units == -1)
n_units = DEFAULT_N_LINES;
/* To start printing with item N_UNITS from the start of the file, skip
N_UNITS - 1 items. `tail +0' is actually meaningless, but for Unix
compatibility it's treated the same as `tail +1'. */
if (from_start)
{
if (n_units)
--n_units;
}
n_files = argc;
file = argv;
if (n_files > 1 && forever)
{
forever_multiple = 1;
forever = 0;
file_descs = (int *) xmalloc (n_files * sizeof (int));
file_sizes = (off_t *) xmalloc (n_files * sizeof (off_t));
}
if (header_mode == always
|| (header_mode == multiple_files && n_files > 1))
print_headers = 1;
if (n_files == 0)
{
exit_status |= tail_file ("-", n_units, 0);
}
else
{
int i;
for (i = 0; i < n_files; i++)
exit_status |= tail_file (file[i], n_units, i);
if (forever_multiple)
tail_forever (file, n_files);
}
if (have_read_stdin && close (0) < 0)
error (EXIT_FAILURE, errno, "-");
if (fclose (stdout) == EOF)
error (EXIT_FAILURE, errno, "write error");
exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}
+126
View File
@@ -0,0 +1,126 @@
/*
* Mini tee implementation for busybox
*
*
* Copyright (C) 1999 by Lineo, inc.
* Written by John Beppu <beppu@lineo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
static const char tee_usage[] =
"tee [OPTION]... [FILE]...\n\n"
"Copy standard input to each FILE, and also to standard output.\n\n"
"Options:\n"
"\t-a\tappend to the given FILEs, do not overwrite\n"
#if 0
"\t-i\tignore interrupt signals\n"
#endif
;
/* FileList _______________________________________________________________ */
#define FL_MAX 1024
static FILE *FileList[FL_MAX];
static int FL_end;
typedef void (FL_Function)(FILE *file, char c);
/* apply a function to everything in FileList */
static void
FL_apply(FL_Function *f, char c)
{
int i;
for (i = 0; i <= FL_end; i++) {
f(FileList[i], c);
}
}
/* FL_Function for writing to files*/
static void
tee_fwrite(FILE *file, char c)
{
fputc(c, file);
}
/* FL_Function for closing files */
static void
tee_fclose(FILE *file, char c)
{
fclose(file);
}
/* ________________________________________________________________________ */
/* BusyBoxed tee(1) */
int
tee_main(int argc, char **argv)
{
int i;
char c;
char opt;
char opt_fopen[2] = "w";
FILE *file;
/* parse argv[] */
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
opt = argv[i][1];
switch (opt) {
case 'a':
opt_fopen[0] = 'a';
break;
#if 0
case 'i':
fprintf(stderr, "ignore interrupt not implemented\n");
break;
#endif
default:
usage(tee_usage);
}
} else {
break;
}
}
/* init FILE pointers */
FL_end = 0;
FileList[0] = stdout;
for ( ; i < argc; i++) {
/* add a file to FileList */
file = fopen(argv[i], opt_fopen);
if (!file) { continue; }
if (FL_end < FL_MAX) {
FileList[++FL_end] = file;
}
}
/* read and redirect */
while ((c = (char) getchar()) && (!feof(stdin))) {
FL_apply(tee_fwrite, c);
}
/* clean up */
FL_apply(tee_fclose, 0);
exit(0);
}
/* $Id: tee.c,v 1.4 1999/12/10 08:25:07 andersen Exp $ */
+2 -2
View File
@@ -31,7 +31,7 @@
static const char touch_usage[] = "touch [-c] file [file ...]\n\n"
"\tUpdate the last-modified date on the given file[s].\n";
"Update the last-modified date on the given file[s].\n";
@@ -54,7 +54,7 @@ touch_main(int argc, char **argv)
create = FALSE;
break;
default:
fprintf(stderr, "Unknown option: %c\n", **argv);
usage( touch_usage);
exit( FALSE);
}
argc--;
+42
View File
@@ -0,0 +1,42 @@
/*
* Mini tty implementation for busybox
*
* Copyright (C) 2000 Edward Betts <edward@debian.org>.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
#include <sys/types.h>
static const char tty_usage[] = "tty\n\n"
"Print the file name of the terminal connected to standard input.\n"
"\t-s\tprint nothing, only return an exit status\n";
extern int tty_main(int argc, char **argv) {
char *tty;
if (argc > 1) {
if (argv[1][0] != '-' || argv[1][1] != 's') usage (tty_usage);
}
else {
tty = ttyname (0);
if (tty) puts (tty);
else puts ("not a tty");
}
exit (isatty (0) ? TRUE : FALSE);
}
+3 -2
View File
@@ -41,8 +41,9 @@
static const char uname_usage[] =
"uname [OPTION]...\n"
"Print certain system information. With no OPTION, same as -s.\n"
"uname [OPTION]...\n\n"
"Print certain system information. With no OPTION, same as -s.\n\n"
"Options:\n"
"\t-a\tprint all information\n"
"\t-m\tthe machine (hardware) type\n"
"\t-n\tprint the machine's network node hostname\n"
+196
View File
@@ -0,0 +1,196 @@
/*
* Mini uniq implementation for busybox
*
*
* Copyright (C) 1999 by Lineo, inc.
* Written by John Beppu <beppu@lineo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
#include <string.h>
#include <errno.h>
static const char uniq_usage[] =
"Usage: uniq [OPTION]... [INPUT [OUTPUT]]\n"
"Discard all but one of successive identical lines from INPUT (or\n"
"standard input), writing to OUTPUT (or standard output).\n"
"\n"
"\t-h\tdisplay this help and exit\n"
"\n"
"A field is a run of whitespace, then non-whitespace characters.\n"
"Fields are skipped before chars.\n"
;
/* max chars in line */
#define UNIQ_MAX 4096
typedef void (Print)(FILE *, const char *);
typedef int (Decide)(const char *, const char *);
/* container for two lines to be compared */
typedef struct {
char *a;
char *b;
int recurrence;
FILE *in;
FILE *out;
void *func;
} Subject;
/* set up all the variables of a uniq operation */
static Subject *
subject_init(Subject *self, FILE *in, FILE *out, void *func)
{
self->a = NULL;
self->b = NULL;
self->in = in;
self->out = out;
self->func = func;
self->recurrence = 0;
return self;
}
/* point a and b to the appropriate lines;
* count the recurrences (if any) of a string;
*/
static Subject *
subject_next(Subject *self)
{
/* tmp line holders */
static char line[2][UNIQ_MAX];
static int alternator = 0;
if (fgets(line[alternator], UNIQ_MAX, self->in)) {
self->a = self->b;
self->b = line[alternator];
alternator ^= 1;
return self;
}
return NULL;
}
static Subject *
subject_last(Subject *self)
{
self->a = self->b;
self->b = NULL;
return self;
}
static Subject *
subject_study(Subject *self)
{
if (self->a == NULL) {
return self;
}
if (self->b == NULL) {
fprintf(self->out, "%s", self->a);
return self;
}
if (strcmp(self->a, self->b) == 0) {
self->recurrence++;
} else {
fprintf(self->out, "%s", self->a);
self->recurrence = 0;
}
return self;
}
static int
set_file_pointers(int schema, FILE **in, FILE **out, char **argv)
{
switch (schema) {
case 0:
*in = stdin;
*out = stdout;
break;
case 1:
*in = fopen(argv[0], "r");
*out = stdout;
break;
case 2:
*in = fopen(argv[0], "r");
*out = fopen(argv[1], "w");
break;
}
if (*in == NULL) {
fprintf(stderr, "uniq: %s: %s\n", argv[0], strerror(errno));
return errno;
}
if (*out == NULL) {
fprintf(stderr, "uniq: %s: %s\n", argv[1], strerror(errno));
return errno;
}
return 0;
}
/* one variable is the decision algo */
/* another variable is the printing algo */
/* I don't think I have to have more than a 1 line memory
this is the one constant */
/* it seems like GNU/uniq only takes one or two files as an option */
/* ________________________________________________________________________ */
int
uniq_main(int argc, char **argv)
{
int i;
char opt;
FILE *in, *out;
Subject s;
/* parse argv[] */
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
opt = argv[i][1];
switch (opt) {
case '-':
case 'h':
usage(uniq_usage);
default:
usage(uniq_usage);
}
} else {
break;
}
}
/* 0 src: stdin; dst: stdout */
/* 1 src: file; dst: stdout */
/* 2 src: file; dst: file */
if (set_file_pointers((argc - 1), &in, &out, &argv[i])) {
exit(1);
}
subject_init(&s, in, out, NULL);
while (subject_next(&s)) {
subject_study(&s);
}
subject_last(&s);
subject_study(&s);
exit(0);
}
/* $Id: uniq.c,v 1.4 2000/01/07 01:57:32 beppu Exp $ */
+162
View File
@@ -0,0 +1,162 @@
/*
* Mini wc implementation for busybox
*
* by Edward Betts <edward@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
static const char wc_usage[] = "wc [OPTION]... [FILE]...\n\n"
"Print line, word, and byte counts for each FILE, and a total line if\n"
"more than one FILE is specified. With no FILE, read standard input.\n"
"\t-c\tprint the byte counts\n"
"\t-l\tprint the newline counts\n"
"\t-L\tprint the length of the longest line\n"
"\t-L\tprint the length of the longest line\n"
"\t-w\tprint the word counts\n";
static int total_lines, total_words, total_chars, max_length;
static int print_lines, print_words, print_chars, print_length;
void print_counts (int lines, int words, int chars, int length,
const char *name) {
char const *space = "";
if (print_lines) {
printf ("%7d", lines);
space = " ";
}
if (print_words) {
printf ("%s%7d", space, words);
space = " ";
}
if (print_chars) {
printf ("%s%7d", space, chars);
space = " ";
}
if (print_length)
printf ("%s%7d", space, length);
if (*name)
printf (" %s", name);
putchar ('\n');
}
static void wc_file(FILE *file, const char *name)
{
int lines, words, chars, length;
int in_word = 0, linepos = 0;
int c;
lines = words = chars = length = 0;
while ((c = getc(file)) != EOF) {
chars++;
switch (c) {
case '\n':
lines++;
case '\r':
case '\f':
if (linepos > length)
length = linepos;
linepos = 0;
goto word_separator;
case '\t':
linepos += 8 - (linepos % 8);
goto word_separator;
case ' ':
linepos++;
case '\v':
word_separator:
if (in_word) {
in_word = 0;
words++;
}
break;
default:
linepos++;
in_word = 1;
break;
}
}
if (linepos > length)
length = linepos;
if (in_word)
words++;
print_counts (lines, words, chars, length, name);
total_lines += lines;
total_words += words;
total_chars += chars;
if (length > max_length)
max_length = length;
fclose(file);
fflush(stdout);
}
int wc_main(int argc, char **argv) {
FILE *file;
total_lines = total_words = total_chars = max_length = 0;
print_lines = print_words = print_chars = print_length = 0;
while (--argc && **(++argv) == '-') {
while (*++(*argv))
switch (**argv) {
case 'c':
print_chars = 1;
break;
case 'l':
print_lines = 1;
break;
case 'L':
print_length = 1;
break;
case 'w':
print_words = 1;
break;
default:
usage (wc_usage);
}
}
if (!print_lines && !print_words && !print_chars && !print_length)
print_lines = print_words = print_chars = 1;
if (argc == 0) {
wc_file(stdin, "");
exit(TRUE);
}
else if (argc == 1) {
file = fopen(*argv, "r");
if (file == NULL) {
perror(*argv);
exit(FALSE);
}
wc_file(file, *argv);
}
else {
while (argc-- > 0 && *argv != '\0' && strlen(*argv)) {
file = fopen(*argv, "r");
if (file == NULL) {
perror(*argv);
exit(FALSE);
}
wc_file(file, *argv);
argv++;
}
print_counts (total_lines, total_words, total_chars,
max_length, "total");
}
exit(TRUE);
}
+44
View File
@@ -0,0 +1,44 @@
/*
* Mini whoami implementation for busybox
*
* Copyright (C) 2000 Edward Betts <edward@debian.org>.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
#include <pwd.h>
static const char whoami_usage[] = "whoami\n\n"
"Print the user name associated with the current effective user id.\n"
"Same as id -un.\n";
extern int whoami_main(int argc, char **argv) {
struct passwd *pw;
uid_t uid;
if (argc > 1) usage (whoami_usage);
uid = geteuid ();
pw = getpwuid (uid);
if (pw) {
puts (pw->pw_name);
exit (TRUE);
}
fprintf (stderr, "%s: cannot find username for UID %u\n", argv[0], (unsigned) uid);
exit (FALSE);
}
+41
View File
@@ -0,0 +1,41 @@
/*
* Mini yes implementation for busybox
*
* Copyright (C) 2000 Edward Betts <edward@debian.org>.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
extern int yes_main(int argc, char **argv) {
int i;
if (argc == 1)
while (1)
if (puts ("y") == EOF) {
perror ("yes");
exit(FALSE);
}
while (1)
for (i = 1; i < argc; i++)
if (fputs (argv[i], stdout) == EOF || putchar (i == argc - 1 ? '\n' : ' ') == EOF) {
perror ("yes");
exit(FALSE);
}
exit(TRUE);
}
+27 -15
View File
@@ -28,12 +28,12 @@
#include <dirent.h>
static const char cp_usage[] = "cp [OPTION]... SOURCE DEST\n"
" or: cp [OPTION]... SOURCE... DIRECTORY\n"
" or: cp [OPTION]... SOURCE... DIRECTORY\n\n"
"Copy SOURCE to DEST, or multiple SOURCE(s) to DIRECTORY.\n"
"\n"
"\t-a\tsame as -dpR\n"
"\t-d\tpreserve links\n"
"\t-p\tpreserve file attributes if possable\n"
"\t-p\tpreserve file attributes if possible\n"
"\t-R\tcopy directories recursively\n";
@@ -42,25 +42,39 @@ static int followLinks = FALSE;
static int preserveFlag = FALSE;
static const char *srcName;
static const char *destName;
static const char *skipName;
static int dirFlag = FALSE;
static int destDirFlag = FALSE;
static int srcDirFlag = FALSE;
static int fileAction(const char *fileName, struct stat* statbuf)
{
char newdestName[NAME_MAX];
char* newsrcName = NULL;
strcpy(newdestName, destName);
if (dirFlag==TRUE) {
strcat(newdestName, "/");
if ( skipName != NULL)
strcat(newdestName, strstr(fileName, skipName));
if ( srcDirFlag == TRUE ) {
if (recursiveFlag!=TRUE ) {
fprintf(stderr, "cp: %s: omitting directory\n", srcName);
return( TRUE);
}
strcat(newdestName, strstr(fileName, srcName) + strlen(srcName));
}
if (destDirFlag==TRUE && srcDirFlag == FALSE) {
if (newdestName[strlen(newdestName)-1] != '/' ) {
strcat(newdestName, "/");
}
newsrcName = strrchr(srcName, '/');
if (newsrcName && *newsrcName != '\0')
strcat(newdestName, newsrcName);
else
strcat(newdestName, srcName);
}
return (copyFile(fileName, newdestName, preserveFlag, followLinks));
}
extern int cp_main(int argc, char **argv)
{
if (argc < 3) {
usage (cp_usage);
}
@@ -94,18 +108,16 @@ extern int cp_main(int argc, char **argv)
destName = argv[argc - 1];
dirFlag = isDirectory(destName);
destDirFlag = isDirectory(destName);
if ((argc > 3) && dirFlag==FALSE) {
if ((argc > 3) && destDirFlag==FALSE) {
fprintf(stderr, "%s: not a directory\n", destName);
exit (FALSE);
}
while (argc-- > 1) {
srcName = *(argv++);
skipName = strrchr(srcName, '/');
if (skipName)
skipName++;
srcDirFlag = isDirectory(srcName);
if (recursiveAction(srcName, recursiveFlag, followLinks, FALSE,
fileAction, fileAction) == FALSE) {
exit( FALSE);
+1 -1
View File
@@ -35,7 +35,7 @@
mail commands */
static const char date_usage[] = "date [OPTION]... [+FORMAT]\n"
" or: date [OPTION] [MMDDhhmm[[CC]YY][.ss]]\n"
" or: date [OPTION] [MMDDhhmm[[CC]YY][.ss]]\n\n"
"Display the current time in the given FORMAT, or set the system date.\n"
"\nOptions:\n\t-R\t\toutput RFC-822 compliant date string\n"
"\t-s\t\tset time described by STRING\n"
+30 -70
View File
@@ -29,12 +29,18 @@
#include "internal.h"
#include <features.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
#include <inttypes.h>
#else
typedef unsigned long long int uintmax_t;
#endif
static const char dd_usage[] =
"dd [if=name] [of=name] [bs=n] [count=n]\n"
"dd [if=name] [of=name] [bs=n] [count=n]\n\n"
"Copy a file, converting and formatting according to options\n\n"
"\tif=FILE\tread from FILE instead of stdin\n"
"\tof=FILE\twrite to FILE instead of stout\n"
@@ -42,77 +48,26 @@ static const char dd_usage[] =
"\tcount=n\tcopy only n input blocks\n"
//"\tskip=n\tskip n input blocks\n"
"\n"
"BYTES may be suffixed: by k for x1024, b for x512, and w for x2.\n";
"BYTES may be suffixed by w (x2), k (x1024), b (x512), or m (x1024^2).\n";
/*
* Read a number with a possible multiplier.
* Returns -1 if the number format is illegal.
*/
static long getNum (const char *cp)
{
long value;
if (!isDecimal (*cp))
return -1;
value = 0;
while (isDecimal (*cp))
value = value * 10 + *cp++ - '0';
switch (*cp++) {
case 'k':
value *= 1024;
break;
case 'b':
value *= 512;
break;
case 'w':
value *= 2;
break;
case '\0':
return value;
default:
return -1;
}
if (*cp)
return -1;
return value;
}
extern int dd_main (int argc, char **argv)
{
const char *inFile;
const char *outFile;
const char *inFile = NULL;
const char *outFile = NULL;
char *cp;
int inFd;
int outFd;
int inCc = 0;
int outCc;
int skipBlocks;
int blockSize;
long count;
long intotal;
long outTotal;
size_t blockSize = 512;
//uintmax_t skipBlocks = 0;
uintmax_t count = (uintmax_t)-1;
uintmax_t intotal;
uintmax_t outTotal;
unsigned char *buf;
inFile = NULL;
outFile = NULL;
blockSize = 512;
skipBlocks = 0;
count = 1;
argc--;
argv++;
@@ -125,14 +80,14 @@ extern int dd_main (int argc, char **argv)
else if (strncmp("count", *argv, 5) == 0) {
count = getNum ((strchr(*argv, '='))+1);
if (count <= 0) {
fprintf (stderr, "Bad count value %ld\n", count);
fprintf (stderr, "Bad count value %s\n", *argv);
goto usage;
}
}
else if (strncmp(*argv, "bs", 2) == 0) {
blockSize = getNum ((strchr(*argv, '='))+1);
if (blockSize <= 0) {
fprintf (stderr, "Bad block size value %d\n", blockSize);
fprintf (stderr, "Bad block size value %s\n", *argv);
goto usage;
}
}
@@ -152,8 +107,6 @@ extern int dd_main (int argc, char **argv)
argc--;
argv++;
}
if ( inFile == NULL || outFile == NULL)
goto usage;
buf = malloc (blockSize);
if (buf == NULL) {
@@ -165,7 +118,7 @@ extern int dd_main (int argc, char **argv)
outTotal = 0;
if (inFile == NULL)
inFd = STDIN;
inFd = fileno(stdin);
else
inFd = open (inFile, 0);
@@ -176,7 +129,7 @@ extern int dd_main (int argc, char **argv)
}
if (outFile == NULL)
outFd = STDOUT;
outFd = fileno(stdout);
else
outFd = creat (outFile, 0666);
@@ -188,11 +141,17 @@ extern int dd_main (int argc, char **argv)
}
//lseek(inFd, skipBlocks*blockSize, SEEK_SET);
//
//TODO: Convert to using fullRead & fullWrite
// from utilitity.c
// -Erik
while (outTotal < count * blockSize) {
inCc = read (inFd, buf, blockSize);
if (inCc < 0) {
perror (inFile);
goto cleanup;
} else if (inCc == 0) {
goto cleanup;
}
intotal += inCc;
cp = buf;
@@ -204,6 +163,8 @@ extern int dd_main (int argc, char **argv)
if (outCc < 0) {
perror (outFile);
goto cleanup;
} else if (outCc == 0) {
goto cleanup;
}
inCc -= outCc;
@@ -220,15 +181,14 @@ extern int dd_main (int argc, char **argv)
close (outFd);
free (buf);
printf ("%ld+%d records in\n", intotal / blockSize,
printf ("%ld+%d records in\n", (long)(intotal / blockSize),
(intotal % blockSize) != 0);
printf ("%ld+%d records out\n", outTotal / blockSize,
printf ("%ld+%d records out\n", (long)(outTotal / blockSize),
(outTotal % blockSize) != 0);
exit( TRUE);
usage:
fprintf (stderr, "%s", dd_usage);
exit( FALSE);
usage( dd_usage);
}
+4 -2
View File
@@ -17,8 +17,10 @@ int
deallocvt_main(int argc, char *argv[]) {
int fd, num, i;
if (argc < 1) /* unlikely */
exit(1);
if ( ( argc != 2) || (**(argv+1) == '-' ) ) {
usage ("deallocvt N\n\nDeallocate unused virtual terminal /dev/ttyN\n");
}
progname = argv[0];
fd = get_console_fd("/dev/console");
+14 -53
View File
@@ -38,19 +38,23 @@ static int df(char *device, const char *mountPoint)
struct statfs s;
long blocks_used;
long blocks_percent_used;
struct fstab* fstabItem;
if (statfs(mountPoint, &s) != 0) {
perror(mountPoint);
return 1;
return FALSE;
}
if (s.f_blocks > 0) {
blocks_used = s.f_blocks - s.f_bfree;
blocks_percent_used = (long)
(blocks_used * 100.0 / (blocks_used + s.f_bavail) + 0.5);
if (strcmp(device, "/dev/root") == 0)
device = (getfsfile("/"))->fs_spec;
/* Note that if /etc/fstab is missing, libc can't fix up /dev/root for us */
if (strcmp (device, "/dev/root") == 0) {
fstabItem = getfsfile ("/");
if (fstabItem != NULL)
device = fstabItem->fs_spec;
}
printf("%-20s %9ld %9ld %9ld %3ld%% %s\n",
device,
(long) (s.f_blocks * (s.f_bsize / 1024.0)),
@@ -60,50 +64,9 @@ static int df(char *device, const char *mountPoint)
}
return 0;
return TRUE;
}
/*
* Given a block device, find the mount table entry if that block device
* is mounted.
*
* Given any other file (or directory), find the mount table entry for its
* filesystem.
*/
extern struct mntent *findMountPoint(const char *name, const char *table)
{
struct stat s;
dev_t mountDevice;
FILE *mountTable;
struct mntent *mountEntry;
if (stat(name, &s) != 0)
return 0;
if ((s.st_mode & S_IFMT) == S_IFBLK)
mountDevice = s.st_rdev;
else
mountDevice = s.st_dev;
if ((mountTable = setmntent(table, "r")) == 0)
return 0;
while ((mountEntry = getmntent(mountTable)) != 0) {
if (strcmp(name, mountEntry->mnt_dir) == 0
|| strcmp(name, mountEntry->mnt_fsname) == 0) /* String match. */
break;
if (stat(mountEntry->mnt_fsname, &s) == 0 && s.st_rdev == mountDevice) /* Match the device. */
break;
if (stat(mountEntry->mnt_dir, &s) == 0 && s.st_dev == mountDevice) /* Match the directory's mount point. */
break;
}
endmntent(mountTable);
return mountEntry;
}
extern int df_main(int argc, char **argv)
{
printf("%-20s %-14s %s %s %s %s\n", "Filesystem",
@@ -117,15 +80,15 @@ extern int df_main(int argc, char **argv)
if ((mountEntry = findMountPoint(argv[1], mtab_file)) ==
0) {
fprintf(stderr, "%s: can't find mount point.\n", argv[1]);
return 1;
exit( FALSE);
}
status = df(mountEntry->mnt_fsname, mountEntry->mnt_dir);
if (status != 0)
return status;
exit( status);
argc--;
argv++;
}
return 0;
exit( TRUE);
} else {
FILE *mountTable;
struct mntent *mountEntry;
@@ -137,12 +100,10 @@ extern int df_main(int argc, char **argv)
}
while ((mountEntry = getmntent(mountTable))) {
int status = df(mountEntry->mnt_fsname, mountEntry->mnt_dir);
if (status)
return status;
df(mountEntry->mnt_fsname, mountEntry->mnt_dir);
}
endmntent(mountTable);
}
return 0;
exit( TRUE);
}
+13 -5
View File
@@ -44,10 +44,15 @@ int dmesg_main( int argc, char** argv )
int level = 0;
int lastc;
int cmd = 3;
int stopDoingThat;
argc--;
argv++;
/* Parse any options */
while (argc && **argv == '-') {
while (*++(*argv))
stopDoingThat = FALSE;
while (stopDoingThat == FALSE && *++(*argv)) {
switch (**argv) {
case 'c':
cmd = 4;
@@ -57,19 +62,22 @@ int dmesg_main( int argc, char** argv )
if (--argc == 0)
goto end;
level = atoi (*(++argv));
--argc;
++argv;
if (--argc > 0)
++argv;
stopDoingThat = TRUE;
break;
case 's':
if (--argc == 0)
goto end;
bufsize = atoi (*(++argv));
--argc;
++argv;
if (--argc > 0)
++argv;
stopDoingThat = TRUE;
break;
default:
goto end;
}
}
}
if (argc > 1) {
+1025
View File
File diff suppressed because it is too large. Load diff
+143
View File
@@ -0,0 +1,143 @@
/*
* Mini du implementation for busybox
*
*
* Copyright (C) 1999 by Lineo, inc.
* Written by John Beppu <beppu@lineo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <sys/types.h>
#include <fcntl.h>
#include <dirent.h>
#include <stdio.h>
#include <errno.h>
#if 0
#include <unistd.h>
#include <sys/stat.h>
#endif
typedef void (Display)(size_t, char *);
static const char du_usage[] =
"Usage: du [OPTION]... [FILE]...\n\n"
"\t-s\tdisplay only a total for each argument\n"
;
static int du_depth = 0;
static Display *print;
static void
print_normal(size_t size, char *filename)
{
fprintf(stdout, "%-7d %s\n", (size >> 1), filename);
}
static void
print_summary(size_t size, char *filename)
{
if (du_depth == 1) {
print_normal(size, filename);
}
}
/* tiny recursive du */
static size_t
du(char *filename)
{
struct stat statbuf;
size_t sum;
if ((lstat(filename, &statbuf)) != 0) {
fprintf(stdout, "du: %s: %s\n", filename, strerror(errno));
return 0;
}
du_depth++;
sum = statbuf.st_blocks;
if (S_ISDIR(statbuf.st_mode)) {
DIR *dir;
struct dirent *entry;
dir = opendir(filename);
if (!dir) { return 0; }
while ((entry = readdir(dir))) {
char newfile[512];
char *name = entry->d_name;
if ( (strcmp(name, "..") == 0)
|| (strcmp(name, ".") == 0))
{ continue; }
sprintf(newfile, "%s/%s", filename, name);
sum += du(newfile);
}
closedir(dir);
print(sum, filename);
}
du_depth--;
return sum;
}
int
du_main(int argc, char **argv)
{
int i;
char opt;
/* default behaviour */
print = print_normal;
/* parse argv[] */
for (i = 1; i < argc; i++) {
if (argv[i][0] == '-') {
opt = argv[i][1];
switch (opt) {
case 's':
print = print_summary;
break;
case 'h':
usage(du_usage);
break;
default:
fprintf(stderr, "du: invalid option -- %c\n", opt);
usage(du_usage);
}
} else {
break;
}
}
/* go through remaining args (if any) */
if (i >= argc) {
du(".");
} else {
int sum;
for ( ; i < argc; i++) {
sum = du(argv[i]);
if ((sum) && (isDirectory(argv[i]))) { print_normal(sum, argv[i]); }
}
}
exit(0);
}
/* $Id: du.c,v 1.8 1999/12/17 18:44:15 erik Exp $ */
+1 -1
View File
@@ -19,7 +19,7 @@ static const char dutmp_usage[] = "dutmp\n"
"\tDump file or stdin utmp file format to stdout, pipe delimited.\n"
"\tdutmp /var/run/utmp\n";
static int dutmp_main (int argc, char **argv)
extern int dutmp_main (int argc, char **argv)
{
FILE *f = stdin;
+268 -96
View File
@@ -5,6 +5,11 @@
* Copyright (C) 1999 by Lineo, inc.
* Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
*
* Modifications for addresses and append command have been
* written by Marco Pantaleoni <panta@prosa.it>, <panta@elasticworld.org>
* and are:
* Copyright (C) 1999 Marco Pantaleoni.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
@@ -31,36 +36,144 @@
#include <time.h>
#include <ctype.h>
static const char sed_usage[] =
"sed [-n] [-e script] [file...]\n"
"Allowed scripts come in the following form:\n\n"
"'s/regexp/replacement/[gp]'\n"
"\tattempt to match regexp against the pattern space\n"
"\tand if successful replaces the matched portion with replacement.\n\n"
"Options:\n"
"-e\tadd the script to the commands to be executed\n"
"-n\tsuppress automatic printing of pattern space\n\n"
static const char sed_usage[] =
"sed [-n] -e script [file...]\n\n"
"Allowed sed scripts come in the following form:\n"
"\t'ADDR [!] COMMAND'\n\n"
"\twhere address ADDR can be:\n"
"\t NUMBER Match specified line number\n"
"\t $ Match last line\n"
"\t /REGEXP/ Match specified regexp\n"
"\t (! inverts the meaning of the match)\n\n"
"\tand COMMAND can be:\n"
"\t s/regexp/replacement/[igp]\n"
"\t which attempt to match regexp against the pattern space\n"
"\t and if successful replaces the matched portion with replacement.\n\n"
"\t aTEXT\n"
"\t which appends TEXT after the pattern space\n"
"Options:\n"
"-e\tadd the script to the commands to be executed\n"
"-n\tsuppress automatic printing of pattern space\n\n"
#if defined BB_REGEXP
"This version of sed matches full regexps.\n";
"This version of sed matches full regular expresions.\n";
#else
"This version of sed matches strings (not full regexps).\n";
"This version of sed matches strings (not full regular expresions).\n";
#endif
/* Flags & variables */
typedef enum { f_none, f_replace, f_append } sed_function;
#define NO_LINE -2
#define LAST_LINE -1
static int addr_line = NO_LINE;
static char *addr_pattern = NULL;
static int negated = 0;
extern int sed_main (int argc, char **argv)
#define SKIPSPACES(p) do { while (isspace(*(p))) (p)++; } while (0)
#define BUFSIZE 1024
static inline int at_last(FILE * fp)
{
int res = 0;
if (feof(fp))
return 1;
else {
char ch;
if ((ch = fgetc(fp)) == EOF)
res++;
ungetc(ch, fp);
}
return res;
}
static void do_sed_repl(FILE * fp, char *needle, char *newNeedle,
int ignoreCase, int printFlag, int quietFlag)
{
int foundOne = FALSE;
char haystack[BUFSIZE];
int line = 1, doit;
while (fgets(haystack, BUFSIZE - 1, fp)) {
doit = 0;
if (addr_pattern) {
doit = !find_match(haystack, addr_pattern, FALSE);
} else if (addr_line == NO_LINE)
doit = 1;
else if (addr_line == LAST_LINE) {
if (at_last(fp))
doit = 1;
} else {
if (line == addr_line)
doit = 1;
}
if (negated)
doit = 1 - doit;
if (doit) {
foundOne =
replace_match(haystack, needle, newNeedle, ignoreCase);
if (foundOne == TRUE && printFlag == TRUE) {
fprintf(stdout, haystack);
}
}
if (quietFlag == FALSE) {
fprintf(stdout, haystack);
}
line++;
}
}
static void do_sed_append(FILE * fp, char *appendline, int quietFlag)
{
char buffer[BUFSIZE];
int line = 1, doit;
while (fgets(buffer, BUFSIZE - 1, fp)) {
doit = 0;
if (addr_pattern) {
doit = !find_match(buffer, addr_pattern, FALSE);
} else if (addr_line == NO_LINE)
doit = 1;
else if (addr_line == LAST_LINE) {
if (at_last(fp))
doit = 1;
} else {
if (line == addr_line)
doit = 1;
}
if (negated)
doit = 1 - doit;
if (quietFlag == FALSE) {
fprintf(stdout, buffer);
}
if (doit) {
fputs(appendline, stdout);
fputc('\n', stdout);
}
line++;
}
}
extern int sed_main(int argc, char **argv)
{
FILE *fp;
char *needle=NULL, *newNeedle=NULL;
char *needle = NULL, *newNeedle = NULL;
char *name;
char *cp;
int ignoreCase=FALSE;
int foundOne=FALSE;
int printFlag=FALSE;
int quietFlag=FALSE;
int ignoreCase = FALSE;
int printFlag = FALSE;
int quietFlag = FALSE;
int stopNow;
char *haystack;
char *line_s = NULL, saved;
char *appendline = NULL;
char *pos;
sed_function sed_f = f_none;
argc--;
argv++;
@@ -71,110 +184,169 @@ extern int sed_main (int argc, char **argv)
if (**argv == '-') {
argc--;
cp = *argv++;
stopNow=FALSE;
stopNow = FALSE;
while (*++cp && stopNow==FALSE)
while (*++cp && stopNow == FALSE) {
switch (*cp) {
case 'n':
quietFlag = TRUE;
break;
case 'e':
if (*(cp+1)==0 && --argc < 0) {
fprintf(stderr, "A\n");
usage( sed_usage);
if (*(cp + 1) == 0 && --argc < 0) {
usage(sed_usage);
}
cp = *argv++;
while( *cp ) {
if (*cp == 's' && strlen(cp) > 3 && *(cp+1) == '/') {
char* pos=needle=cp+2;
for(;;) {
pos = strchr(pos, '/');
if (pos==NULL) {
fprintf(stderr, "B\n");
usage( sed_usage);
}
if (*(pos-1) == '\\') {
pos++;
continue;
}
break;
if (*++cp != 's')
cp = *argv++;
/* Read address if present */
SKIPSPACES(cp);
if (*cp == '$') {
addr_line = LAST_LINE;
cp++;
} else {
if (isdigit(*cp)) { /* LINE ADDRESS */
line_s = cp;
while (isdigit(*cp))
cp++;
if (cp > line_s) {
/* numeric line */
saved = *cp;
*cp = '\0';
addr_line = atoi(line_s);
*cp = saved;
}
*pos=0;
newNeedle=++pos;
for(;;) {
pos = strchr(pos, '/');
if (pos==NULL) {
fprintf(stderr, "C\n");
usage( sed_usage);
}
if (*(pos-1) == '\\') {
pos++;
continue;
}
break;
} else if (*cp == '/') { /* PATTERN ADDRESS */
pos = addr_pattern = cp + 1;
pos = strchr(pos, '/');
if (!pos)
usage(sed_usage);
*pos = '\0';
cp = pos + 1;
}
}
SKIPSPACES(cp);
if (*cp == '!') {
negated++;
cp++;
}
/* Read command */
SKIPSPACES(cp);
switch (*cp) {
case 's': /* REPLACE */
if (strlen(cp) <= 3 || *(cp + 1) != '/')
break;
sed_f = f_replace;
pos = needle = cp + 2;
for (;;) {
pos = strchr(pos, '/');
if (pos == NULL) {
usage(sed_usage);
}
*pos=0;
if (pos+2 != 0) {
while (*++pos) {
fprintf(stderr, "pos='%s'\n", pos);
switch (*pos) {
case 'i':
ignoreCase=TRUE;
break;
case 'p':
printFlag=TRUE;
break;
case 'g':
break;
default:
usage( sed_usage);
}
if (*(pos - 1) == '\\') {
pos++;
continue;
}
break;
}
*pos = 0;
newNeedle = ++pos;
for (;;) {
pos = strchr(pos, '/');
if (pos == NULL) {
usage(sed_usage);
}
if (*(pos - 1) == '\\') {
pos++;
continue;
}
break;
}
*pos = 0;
if (pos + 2 != 0) {
while (*++pos) {
switch (*pos) {
case 'i':
ignoreCase = TRUE;
break;
case 'p':
printFlag = TRUE;
break;
case 'g':
break;
default:
usage(sed_usage);
}
}
}
cp++;
cp = pos;
/* fprintf(stderr, "replace '%s' with '%s'\n", needle, newNeedle); */
break;
case 'a': /* APPEND */
if (strlen(cp) < 2)
break;
sed_f = f_append;
appendline = ++cp;
/* fprintf(stderr, "append '%s'\n", appendline); */
break;
}
fprintf(stderr, "replace '%s' with '%s'\n", needle, newNeedle);
stopNow=TRUE;
stopNow = TRUE;
break;
default:
fprintf(stderr, "D\n");
usage(sed_usage);
}
}
}
while (argc-- > 0) {
name = *argv++;
fp = fopen (name, "r");
if (fp == NULL) {
perror (name);
continue;
if (argc == 0) {
switch (sed_f) {
case f_none:
break;
case f_replace:
do_sed_repl(stdin, needle, newNeedle, ignoreCase, printFlag,
quietFlag);
break;
case f_append:
do_sed_append(stdin, appendline, quietFlag);
break;
}
} else {
while (argc-- > 0) {
name = *argv++;
haystack = (char*)malloc( 1024);
while (fgets (haystack, 1023, fp)) {
fp = fopen(name, "r");
if (fp == NULL) {
perror(name);
continue;
}
foundOne = replace_match(haystack, needle, newNeedle, ignoreCase);
if (foundOne==TRUE && printFlag==TRUE)
fputs (haystack, stdout);
if (quietFlag==FALSE)
fputs (haystack, stdout);
/* Avoid any mem leaks */
free(haystack);
haystack = (char*)malloc( BUF_SIZE);
switch (sed_f) {
case f_none:
break;
case f_replace:
do_sed_repl(fp, needle, newNeedle, ignoreCase, printFlag,
quietFlag);
break;
case f_append:
do_sed_append(fp, appendline, quietFlag);
break;
}
if (ferror(fp))
perror(name);
fclose(fp);
}
if (ferror (fp))
perror (name);
fclose (fp);
}
exit( TRUE);
exit(TRUE);
}
/* END CODE */
+4 -12
View File
@@ -1,5 +1,5 @@
Name: busybox
Version: 0.32
Version: 0.41
Release: 1
Group: System/Utilities
Summary: BusyBox is a tiny suite of Unix utilities in a multi-call binary.
@@ -7,7 +7,7 @@ Copyright: GPL
Packager : Erik Andersen <andersen@lineo.com>
Conflicts: fileutils grep shellutils
Buildroot: /tmp/%{Name}-%{Version}
Source: busybox-0.32.tar.gz
Source: %{Name}-%{Version}.tar.gz
%Description
BusyBox is a suite of "tiny" Unix utilities in a multi-call binary. It
@@ -18,22 +18,14 @@ is makes an excellent environment for a "rescue" disk or any small or
embedded system.
%Prep
%setup -q -n busybox
%setup -q -n %{Name}-%{Version}
%Build
make
%Install
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT/bin
h=`cat busybox.links`
for i in $h ; do
mkdir -p $RPM_BUILD_ROOT/`echo $i | sed -e 's/\(^.*\/\)\(.*\)/\1/g' `
(cd $RPM_BUILD_ROOT/bin ; ln -s busybox `echo $i | sed -e 's/\(^.*\/\)\(.*\)/\2/g' ` );
done
rm -f $RPM_BUILD_ROOT/bin/busybox
install -m 755 busybox $RPM_BUILD_ROOT/bin/busybox
make PREFIX=$RPM_BUILD_ROOT install
%Clean
rm -rf $RPM_BUILD_ROOT
+75
View File
@@ -0,0 +1,75 @@
# /etc/inittab init(8) configuration for BusyBox
#
# Copyright (C) 1999 by Lineo, inc. Written by Erik Andersen
# <andersen@lineo.com>, <andersee@debian.org>
#
#
# Note, BusyBox init doesn't support runlevels. The runlevels field is
# completely ignored by BusyBox init. If you want runlevels, use sysvinit.
#
#
# Format for each entry: <id>:<runlevels>:<action>:<process>
#
# <id>: WARNING: This field has a non-traditional meaning for BusyBox init!
#
# The id field is used by BusyBox init to specify the controlling tty for
# the specified process to run on. The contents of this field are
# appended to "/dev/" and used as-is. There is no need for this field to
# be unique, although if it isn't you may have strange results. If this
# field is left blank, it is completely ignored. Also note that if
# BusyBox detects that a serial console is in use, then all entries
# containing non-empty id fields will _not_ be run. BusyBox init does
# nothing with utmp. We don't need no stinkin' utmp.
#
# <runlevels>: The runlevels field is completely ignored.
#
# <action>: Valid actions include: sysinit, respawn, askfirst, wait, and once.
#
# Note: askfirst acts just like respawn, but before running the specified
# process it displays the line "Please press Enter to activate this
# console." and then waits for the user to press enter before starting
# the specified process.
#
# Note: unrecognised actions (like initdefault) will cause init to emit
# an error message, and then go along with its business.
#
# <process>: Specifies the process to be executed and it's command line.
#
# Note: BusyBox init works just fine without an inittab. If no inittab
# is found, it has the following default behavior:
# ::sysinit:/etc/init.d/rcS
# ::askfirst:/bin/sh
# if it detects that /dev/console is _not_ a serial console, it will also run:
# tty2::askfirst:/bin/sh
#
# Boot-time system configuration/initialization script.
# This is run first except when booting in single-user mode.
#
::sysinit:/etc/init.d/rcS
# /bin/sh invocations on selected ttys
#
# Start an "askfirst" shell on the console (whatever that may be)
::askfirst:/bin/sh
# Start an "askfirst" shell on /dev/tty2
tty2::askfirst:/bin/sh
# /sbin/getty invocations for selected ttys
#
tty4::respawn:/sbin/getty 38400 tty4
tty5::respawn:/sbin/getty 38400 tty5
# Example of how to put a getty on a serial line (for a terminal)
#
#ttyS0::respawn:/sbin/getty -L ttyS0 9600 vt100
#ttyS1::respawn:/sbin/getty -L ttyS1 9600 vt100
#
# Example how to put a getty on a modem line.
#ttyS2::respawn:/sbin/getty -x0 -s 57600 ttyS2
# Not currently supported, but may be sometime in the future...
#::ctrlaltdel:/sbin/reboot
+299
View File
@@ -0,0 +1,299 @@
/*
* Mini fbset implementation for busybox
*
* Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* This is a from-scratch implementation of fbset; but the de facto fbset
* implementation was a good reference. fbset (original) is released under
* the GPL, and is (c) 1995-1999 by:
* Geert Uytterhoeven (Geert.Uytterhoeven@cs.kuleuven.ac.be)
*/
#include "internal.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <ctype.h>
#include <sys/ioctl.h>
#include <linux/fb.h>
#include <linux/version.h>
#define PERROR(ctx) do { perror(ctx); exit(1); } while(0)
#ifndef KERNEL_VERSION
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#endif
#define DEFAULTFBDEV "/dev/fb0"
#define DEFAULTFBMODE "/etc/fb.modes"
#define OPT_CHANGE 1
#define OPT_INFO (1 << 1)
#define OPT_READMODE (1 << 2)
#define CMD_HELP 0
#define CMD_FB 1
#define CMD_DB 2
#define CMD_GEOMETRY 3
#define CMD_TIMING 4
#define CMD_ACCEL 5
#define CMD_HSYNC 6
#define CMD_VSYNC 7
#define CMD_LACED 8
#define CMD_DOUBLE 9
/* #define CMD_XCOMPAT 10 */
#define CMD_ALL 11
#define CMD_INFO 12
#ifdef BB_FBSET_FANCY
#define CMD_XRES 13
#define CMD_YRES 14
#define CMD_VXRES 15
#define CMD_VYRES 16
#define CMD_DEPTH 17
#define CMD_MATCH 18
#define CMD_PIXCLOCK 19
#define CMD_LEFT 20
#define CMD_RIGHT 21
#define CMD_UPPER 22
#define CMD_LOWER 23
#define CMD_HSLEN 24
#define CMD_VSLEN 25
#define CMD_CSYNC 26
#define CMD_GSYNC 27
#define CMD_EXTSYNC 28
#define CMD_BCAST 29
#define CMD_RGBA 30
#define CMD_STEP 31
#define CMD_MOVE 32
#endif
static unsigned int g_options = 0;
struct cmdoptions_t {
char *name;
unsigned char param_count;
unsigned char code;
} g_cmdoptions[] = {
{ "-h", 0, CMD_HELP },
{ "-fb", 1, CMD_FB },
{ "-db", 1, CMD_DB },
{ "-a", 0, CMD_ALL },
{ "-i", 0, CMD_INFO },
{ "-g", 5, CMD_GEOMETRY },
{ "-t", 7, CMD_TIMING },
{ "-accel", 1, CMD_ACCEL },
{ "-hsync", 1, CMD_HSYNC },
{ "-vsync", 1, CMD_VSYNC },
{ "-laced", 1, CMD_LACED },
{ "-double", 1, CMD_DOUBLE },
#ifdef BB_FBSET_FANCY
{ "--help", 0, CMD_HELP },
{ "-all", 0, CMD_ALL },
{ "-xres", 1, CMD_XRES },
{ "-yres", 1, CMD_YRES },
{ "-vxres", 1, CMD_VXRES },
{ "-vyres", 1, CMD_VYRES },
{ "-depth", 1, CMD_DEPTH },
{ "-match", 0, CMD_MATCH },
{ "--geometry", 5, CMD_GEOMETRY },
{ "-pixclock", 1, CMD_PIXCLOCK },
{ "-left", 1, CMD_LEFT },
{ "-right", 1, CMD_RIGHT },
{ "-upper", 1, CMD_UPPER },
{ "-lower", 1, CMD_LOWER },
{ "-hslen", 1, CMD_HSLEN },
{ "-vslen", 1, CMD_VSLEN },
{ "--timings", 7, CMD_TIMING },
{ "-csync", 1, CMD_CSYNC },
{ "-gsync", 1, CMD_GSYNC },
{ "-extsync", 1, CMD_EXTSYNC },
{ "-bcast", 1, CMD_BCAST },
{ "-rgba", 1, CMD_RGBA },
{ "-step", 1, CMD_STEP },
{ "-move", 1, CMD_MOVE },
#endif
{ 0, 0, 0 }
};
static int readmode(struct fb_var_screeninfo *base, const char *fn,
const char *mode)
{
#ifdef BB_FBSET_READMODE
FILE *f;
char buf[256];
char *p = buf;
if ((f = fopen(fn, "r")) == NULL) PERROR("readmode(fopen)");
while (!feof(f)) {
fgets(buf, sizeof(buf), f);
if ((p = strstr(buf, "mode ")) || (p = strstr(buf, "mode\t"))) {
p += 5;
if ((p = strstr(buf, mode))) {
p += strlen(mode);
if (!isspace(*p) && (*p != 0) && (*p != '"') && (*p != '\r')
&& (*p != '\n')) continue; /* almost, but not quite */
while (!feof(f)) {
fgets(buf, sizeof(buf), f);
if (!strstr(buf, "endmode")) return 1;
}
}
}
}
#else
fprintf(stderr, "W: mode reading was disabled on this copy of fbset; ignoring request\n");
#endif
return 0;
}
static void setmode(struct fb_var_screeninfo *base,
struct fb_var_screeninfo *set)
{
if ((int)set->xres > 0) base->xres = set->xres;
if ((int)set->yres > 0) base->yres = set->yres;
if ((int)set->xres_virtual > 0) base->xres_virtual = set->xres_virtual;
if ((int)set->yres_virtual > 0) base->yres_virtual = set->yres_virtual;
if ((int)set->bits_per_pixel > 0) base->bits_per_pixel = set->bits_per_pixel;
}
static void showmode(struct fb_var_screeninfo *v)
{
double drate = 0, hrate = 0, vrate = 0;
if (v->pixclock) {
drate = 1e12 / v->pixclock;
hrate = drate / (v->left_margin+v->xres+v->right_margin+v->hsync_len);
vrate = hrate / (v->upper_margin+v->yres+v->lower_margin+v->vsync_len);
}
printf("\nmode \"%ux%u-%u\"\n", v->xres, v->yres, (int)(vrate+0.5));
#ifdef BB_FBSET_FANCY
printf("\t# D: %.3f MHz, H: %.3f kHz, V: %.3f Hz\n", drate/1e6, hrate/1e3,
vrate);
#endif
printf("\tgeometry %u %u %u %u %u\n", v->xres, v->yres,
v->xres_virtual, v->yres_virtual, v->bits_per_pixel);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
printf("\ttimings %u %u %u %u %u %u %u\n", v->pixclock, v->left_margin,
v->right_margin, v->upper_margin, v->lower_margin, v->hsync_len,
v->vsync_len);
printf("\taccel %s\n", (v->accel_flags > 0 ? "true" : "false"));
#else
printf("\ttimings %lu %lu %lu %lu %lu %lu %lu\n", v->pixclock, v->left_margin,
v->right_margin, v->upper_margin, v->lower_margin, v->hsync_len,
v->vsync_len);
#endif
printf("\trgba %u/%u,%u/%u,%u/%u,%u/%u\n", v->red.length, v->red.offset,
v->green.length, v->green.offset, v->blue.length, v->blue.offset,
v->transp.length, v->transp.offset);
printf("endmode\n");
}
static void fbset_usage(void)
{
int i;
#ifndef STANDALONE
fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n", BB_VER, BB_BT);
#endif
fprintf(stderr, "Usage: fbset [options] [mode]\n");
fprintf(stderr, "\tThe following options are recognized:\n");
for (i = 0; g_cmdoptions[i].name; i++)
fprintf(stderr, "\t\t%s\n", g_cmdoptions[i].name);
exit(-1);
}
#ifdef STANDALONE
int main(int argc, char **argv)
#else
extern int fbset_main(int argc, char **argv)
#endif
{
struct fb_var_screeninfo var, varset;
int fh, i;
char *fbdev = DEFAULTFBDEV;
char *modefile = DEFAULTFBMODE;
char *thisarg, *mode = NULL;
memset(&varset, 0xFF, sizeof(varset));
/* parse cmd args.... why do they have to make things so difficult? */
argv++; argc--;
for (; argc > 0 && (thisarg = *argv); argc--, argv++) {
for (i = 0; g_cmdoptions[i].name; i++) {
if (!strcmp(thisarg, g_cmdoptions[i].name)) {
if (argc - 1 < g_cmdoptions[i].param_count) fbset_usage();
switch (g_cmdoptions[i].code) {
case CMD_HELP: fbset_usage();
case CMD_FB: fbdev = argv[1]; break;
case CMD_DB: modefile = argv[1]; break;
case CMD_GEOMETRY:
varset.xres = strtoul(argv[1],0,0);
varset.yres = strtoul(argv[2],0,0);
varset.xres_virtual = strtoul(argv[3],0,0);
varset.yres_virtual = strtoul(argv[4],0,0);
varset.bits_per_pixel = strtoul(argv[5],0,0);
break;
case CMD_TIMING:
varset.pixclock = strtoul(argv[1],0,0);
varset.left_margin = strtoul(argv[2],0,0);
varset.right_margin = strtoul(argv[3],0,0);
varset.upper_margin = strtoul(argv[4],0,0);
varset.lower_margin = strtoul(argv[5],0,0);
varset.hsync_len = strtoul(argv[6],0,0);
varset.vsync_len = strtoul(argv[7],0,0);
break;
#ifdef BB_FBSET_FANCY
case CMD_XRES: varset.xres = strtoul(argv[1],0,0); break;
case CMD_YRES: varset.yres = strtoul(argv[1],0,0); break;
#endif
}
argc -= g_cmdoptions[i].param_count;
argv += g_cmdoptions[i].param_count;
break;
}
}
if (!g_cmdoptions[i].name) {
if (argc == 1) {
mode = *argv;
g_options |= OPT_READMODE;
} else {
fbset_usage();
}
}
}
if ((fh = open(fbdev, O_RDONLY)) < 0) PERROR("fbset(open)");
if (ioctl(fh, FBIOGET_VSCREENINFO, &var)) PERROR("fbset(ioctl)");
if (g_options & OPT_READMODE) {
if (!readmode(&var, modefile, mode)) {
fprintf(stderr, "Unknown video mode `%s'\n", mode);
exit(1);
}
}
setmode(&var, &varset);
if (g_options & OPT_CHANGE)
if (ioctl(fh, FBIOPUT_VSCREENINFO, &var)) PERROR("fbset(ioctl)");
showmode(&var);
close(fh);
return(TRUE);
}
+21 -5
View File
@@ -32,9 +32,18 @@ static char* pattern=NULL;
static char* directory=".";
static int dereferenceFlag=FALSE;
static const char find_usage[] = "find [path...] [expression]\n"
"default path is the current directory; default expression is -print\n"
"expression may consist of:\n";
static const char find_usage[] = "find [PATH...] [EXPRESSION]\n\n"
"Search for files in a directory hierarchy. The default PATH is\n"
"the current directory; default EXPRESSION is '-print'\n\n"
"\nEXPRESSION may consist of:\n"
"\t-follow\n\t\tDereference symbolic links.\n"
"\t-name PATTERN\n\t\tFile name (with leading directories removed) matches PATTERN.\n"
"\t-print\n\t\tprint the full file name followed by a newline to stdout.\n\n"
#if defined BB_REGEXP
"This version of find matches full regular expresions.\n";
#else
"This version of find matches strings (not regular expresions).\n";
#endif
@@ -42,8 +51,15 @@ static int fileAction(const char *fileName, struct stat* statbuf)
{
if (pattern==NULL)
fprintf(stdout, "%s\n", fileName);
else if (find_match((char*)fileName, pattern, TRUE) == TRUE)
fprintf(stdout, "%s\n", fileName);
else {
char* tmp = strrchr( fileName, '/');
if (tmp == NULL)
tmp = (char*)fileName;
else
tmp++;
if (check_wildcard_match(tmp, pattern) == TRUE)
fprintf(stdout, "%s\n", fileName);
}
return( TRUE);
}
+21 -5
View File
@@ -32,9 +32,18 @@ static char* pattern=NULL;
static char* directory=".";
static int dereferenceFlag=FALSE;
static const char find_usage[] = "find [path...] [expression]\n"
"default path is the current directory; default expression is -print\n"
"expression may consist of:\n";
static const char find_usage[] = "find [PATH...] [EXPRESSION]\n\n"
"Search for files in a directory hierarchy. The default PATH is\n"
"the current directory; default EXPRESSION is '-print'\n\n"
"\nEXPRESSION may consist of:\n"
"\t-follow\n\t\tDereference symbolic links.\n"
"\t-name PATTERN\n\t\tFile name (with leading directories removed) matches PATTERN.\n"
"\t-print\n\t\tprint the full file name followed by a newline to stdout.\n\n"
#if defined BB_REGEXP
"This version of find matches full regular expresions.\n";
#else
"This version of find matches strings (not regular expresions).\n";
#endif
@@ -42,8 +51,15 @@ static int fileAction(const char *fileName, struct stat* statbuf)
{
if (pattern==NULL)
fprintf(stdout, "%s\n", fileName);
else if (find_match((char*)fileName, pattern, TRUE) == TRUE)
fprintf(stdout, "%s\n", fileName);
else {
char* tmp = strrchr( fileName, '/');
if (tmp == NULL)
tmp = (char*)fileName;
else
tmp++;
if (check_wildcard_match(tmp, pattern) == TRUE)
fprintf(stdout, "%s\n", fileName);
}
return( TRUE);
}
+69 -41
View File
@@ -21,6 +21,14 @@
*
*/
/*
18-Dec-1999 Konstantin Boldyshev <konst@voshod.com>
+ -q option (be quiet)
+ exit code depending on grep result (TRUE or FALSE)
(useful for scripts)
*/
#include "internal.h"
#include "regexp.h"
#include <stdio.h>
@@ -32,29 +40,60 @@
#include <ctype.h>
static const char grep_usage[] =
"grep [-ihn]... PATTERN [FILE]...\n"
"grep [OPTIONS]... PATTERN [FILE]...\n\n"
"Search for PATTERN in each FILE or standard input.\n\n"
"OPTIONS:\n"
"\t-h\tsuppress the prefixing filename on output\n"
"\t-i\tignore case distinctions\n"
"\t-n\tprint line number with output lines\n\n"
"\t-n\tprint line number with output lines\n"
"\t-q\tbe quiet. Returns 0 if result was found, 1 otherwise\n\n"
#if defined BB_REGEXP
"This version of grep matches full regexps.\n";
"This version of grep matches full regular expresions.\n";
#else
"This version of grep matches strings (not full regexps).\n";
"This version of grep matches strings (not regular expresions).\n";
#endif
static int match = FALSE, beQuiet = FALSE;
static void do_grep(FILE *fp, char* needle, char *fileName, int tellName, int ignoreCase, int tellLine)
{
char *cp;
long line = 0;
char haystack[BUF_SIZE];
while (fgets (haystack, sizeof (haystack), fp)) {
line++;
cp = &haystack[strlen (haystack) - 1];
if (*cp != '\n')
fprintf (stderr, "%s: Line too long\n", fileName);
if (find_match(haystack, needle, ignoreCase) == TRUE) {
if (tellName==TRUE)
printf ("%s:", fileName);
if (tellLine==TRUE)
printf ("%ld:", line);
if (beQuiet==FALSE)
fputs (haystack, stdout);
match = TRUE;
}
}
}
extern int grep_main (int argc, char **argv)
{
FILE *fp;
char *needle;
char *name;
char *cp;
int tellName=TRUE;
char *needle;
char *fileName;
int tellName=FALSE;
int ignoreCase=FALSE;
int tellLine=FALSE;
long line;
char haystack[BUF_SIZE];
ignoreCase = FALSE;
tellLine = FALSE;
@@ -76,13 +115,17 @@ extern int grep_main (int argc, char **argv)
break;
case 'h':
tellName = FALSE;
tellName = TRUE;
break;
case 'n':
tellLine = TRUE;
break;
case 'q':
beQuiet = TRUE;
break;
default:
usage(grep_usage);
}
@@ -91,41 +134,26 @@ extern int grep_main (int argc, char **argv)
needle = *argv++;
argc--;
while (argc-- > 0) {
name = *argv++;
if (argc==0) {
do_grep( stdin, needle, "stdin", FALSE, ignoreCase, tellLine);
} else {
while (argc-- > 0) {
fileName = *argv++;
fp = fopen (name, "r");
if (fp == NULL) {
perror (name);
continue;
}
line = 0;
while (fgets (haystack, sizeof (haystack), fp)) {
line++;
cp = &haystack[strlen (haystack) - 1];
if (*cp != '\n')
fprintf (stderr, "%s: Line too long\n", name);
if (find_match(haystack, needle, ignoreCase) == TRUE) {
if (tellName==TRUE)
printf ("%s: ", name);
if (tellLine==TRUE)
printf ("%ld: ", line);
fputs (haystack, stdout);
fp = fopen (fileName, "r");
if (fp == NULL) {
perror (fileName);
continue;
}
do_grep( fp, needle, fileName, tellName, ignoreCase, tellLine);
if (ferror (fp))
perror (fileName);
fclose (fp);
}
if (ferror (fp))
perror (name);
fclose (fp);
}
exit( TRUE);
exit(match);
}
+35
View File
@@ -0,0 +1,35 @@
/*
* Mini free implementation for busybox
*
* Copyright (C) 1999 by Lineo, inc.
* Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
#if ! defined BB_FEATURE_USE_PROCFS
#error Sorry, I depend on the /proc filesystem right now.
#endif
extern int free_main(int argc, char **argv)
{
char* cmd[] = { "cat", "/proc/meminfo", "\0" };
exit(cat_main( 3, cmd));
}
+11 -3
View File
@@ -191,9 +191,17 @@ static void leave(int status)
}
static void show_usage(void) {
fprintf(stderr,
"Usage: %s [-larvsmf] /dev/name\n",
program_name);
fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n", BB_VER, BB_BT);
fprintf(stderr, "Usage: %s [-larvsmf] /dev/name\n\n", program_name);
fprintf(stderr, "Performs a consistency check for MINIX filesystems.\n\n");
fprintf(stderr, "OPTIONS:\n");
fprintf(stderr, "\t-l\tLists all filenames\n");
fprintf(stderr, "\t-r\tPerform interactive repairs\n");
fprintf(stderr, "\t-a\tPerform automatic repairs\n");
fprintf(stderr, "\t-v\tverbose\n");
fprintf(stderr, "\t-s\tOutputs super-block information\n");
fprintf(stderr, "\t-m\tActivates MINIX-like \"mode not cleared\" warnings\n");
fprintf(stderr, "\t-f\tForce file system check.\n\n");
leave(16);
}
+69 -41
View File
@@ -21,6 +21,14 @@
*
*/
/*
18-Dec-1999 Konstantin Boldyshev <konst@voshod.com>
+ -q option (be quiet)
+ exit code depending on grep result (TRUE or FALSE)
(useful for scripts)
*/
#include "internal.h"
#include "regexp.h"
#include <stdio.h>
@@ -32,29 +40,60 @@
#include <ctype.h>
static const char grep_usage[] =
"grep [-ihn]... PATTERN [FILE]...\n"
"grep [OPTIONS]... PATTERN [FILE]...\n\n"
"Search for PATTERN in each FILE or standard input.\n\n"
"OPTIONS:\n"
"\t-h\tsuppress the prefixing filename on output\n"
"\t-i\tignore case distinctions\n"
"\t-n\tprint line number with output lines\n\n"
"\t-n\tprint line number with output lines\n"
"\t-q\tbe quiet. Returns 0 if result was found, 1 otherwise\n\n"
#if defined BB_REGEXP
"This version of grep matches full regexps.\n";
"This version of grep matches full regular expresions.\n";
#else
"This version of grep matches strings (not full regexps).\n";
"This version of grep matches strings (not regular expresions).\n";
#endif
static int match = FALSE, beQuiet = FALSE;
static void do_grep(FILE *fp, char* needle, char *fileName, int tellName, int ignoreCase, int tellLine)
{
char *cp;
long line = 0;
char haystack[BUF_SIZE];
while (fgets (haystack, sizeof (haystack), fp)) {
line++;
cp = &haystack[strlen (haystack) - 1];
if (*cp != '\n')
fprintf (stderr, "%s: Line too long\n", fileName);
if (find_match(haystack, needle, ignoreCase) == TRUE) {
if (tellName==TRUE)
printf ("%s:", fileName);
if (tellLine==TRUE)
printf ("%ld:", line);
if (beQuiet==FALSE)
fputs (haystack, stdout);
match = TRUE;
}
}
}
extern int grep_main (int argc, char **argv)
{
FILE *fp;
char *needle;
char *name;
char *cp;
int tellName=TRUE;
char *needle;
char *fileName;
int tellName=FALSE;
int ignoreCase=FALSE;
int tellLine=FALSE;
long line;
char haystack[BUF_SIZE];
ignoreCase = FALSE;
tellLine = FALSE;
@@ -76,13 +115,17 @@ extern int grep_main (int argc, char **argv)
break;
case 'h':
tellName = FALSE;
tellName = TRUE;
break;
case 'n':
tellLine = TRUE;
break;
case 'q':
beQuiet = TRUE;
break;
default:
usage(grep_usage);
}
@@ -91,41 +134,26 @@ extern int grep_main (int argc, char **argv)
needle = *argv++;
argc--;
while (argc-- > 0) {
name = *argv++;
if (argc==0) {
do_grep( stdin, needle, "stdin", FALSE, ignoreCase, tellLine);
} else {
while (argc-- > 0) {
fileName = *argv++;
fp = fopen (name, "r");
if (fp == NULL) {
perror (name);
continue;
}
line = 0;
while (fgets (haystack, sizeof (haystack), fp)) {
line++;
cp = &haystack[strlen (haystack) - 1];
if (*cp != '\n')
fprintf (stderr, "%s: Line too long\n", name);
if (find_match(haystack, needle, ignoreCase) == TRUE) {
if (tellName==TRUE)
printf ("%s: ", name);
if (tellLine==TRUE)
printf ("%ld: ", line);
fputs (haystack, stdout);
fp = fopen (fileName, "r");
if (fp == NULL) {
perror (fileName);
continue;
}
do_grep( fp, needle, fileName, tellName, ignoreCase, tellLine);
if (ferror (fp))
perror (fileName);
fclose (fp);
}
if (ferror (fp))
perror (name);
fclose (fp);
}
exit( TRUE);
exit(match);
}
+2334
View File
File diff suppressed because it is too large. Load diff
+117 -38
View File
@@ -7,11 +7,17 @@
#include "internal.h"
#ifdef BB_GZIP
#ifndef BB_ZCAT
#error you need zcat to have gzip support!
#endif
//#ifndef BB_ZCAT
//#error you need zcat to have gzip support!
//#endif
static const char gzip_usage[] =
"gzip [OPTION]... FILE\n\n"
"Compress FILE with maximum compression.\n"
"When FILE is -, reads standard input. Implies -c.\n\n"
"Options:\n"
"\t-c\tWrite output to standard output instead of FILE.gz\n";
static const char gzip_usage[] = "gzip\nignores all command line arguments\ncompress stdin to stdout with -9 compression\n";
/* gzip.h -- common declarations for all gzip modules
* Copyright (C) 1992-1993 Jean-loup Gailly.
@@ -210,7 +216,6 @@ extern int exit_code; /* program exit code */
extern int verbose; /* be verbose (-v) */
extern int quiet; /* be quiet (-q) */
extern int test; /* check .z file integrity */
extern int to_stdout; /* output to stdout (-c) */
extern int save_orig_name; /* set if original name must be saved */
#define get_byte() (inptr < insize ? inbuf[inptr++] : fill_inbuf(0))
@@ -272,7 +277,7 @@ extern int save_orig_name; /* set if original name must be saved */
#define WARN(msg) {if (!quiet) fprintf msg ; \
if (exit_code == OK) exit_code = WARNING;}
local void do_exit(int exitcode);
local void do_exit(int exitcode) __attribute__ ((noreturn));
/* in zip.c: */
extern int zip OF((int in, int out));
@@ -380,7 +385,6 @@ extern int block_mode; /* block compress mode -C compatible with 2.0 */
# undef LZW
#endif
/* $Id: gzip.c,v 1.5 1999/10/23 07:09:58 andersen Exp $ */
/* tailor.h -- target dependent definitions
* Copyright (C) 1992-1993 Jean-loup Gailly.
* This is free software; you can redistribute it and/or modify it under the
@@ -391,7 +395,6 @@ extern int block_mode; /* block compress mode -C compatible with 2.0 */
* The target dependent functions should be defined in tailor.c.
*/
/* $Id: gzip.c,v 1.5 1999/10/23 07:09:58 andersen Exp $ */
#if defined(__MSDOS__) && !defined(MSDOS)
# define MSDOS
@@ -1728,7 +1731,6 @@ DECLARE(uch, window, 2L*WSIZE);
/* local variables */
int ascii = 0; /* convert end-of-lines to local OS conventions */
int to_stdout = 0; /* output to stdout (-c) */
int decompress = 0; /* decompress (-d) */
int no_name = -1; /* don't save or restore the original file name */
int no_time = -1; /* don't save or restore the original file time */
@@ -1760,17 +1762,42 @@ unsigned outcnt; /* bytes in output buffer */
/* local functions */
local void treat_stdin OF((void));
static int (*work) OF((int infile, int outfile)) = zip; /* function to call */
#define strequ(s1, s2) (strcmp((s1),(s2)) == 0)
/* ======================================================================== */
// int main (argc, argv)
// int argc;
// char **argv;
int gzip_main(int argc, char * * argv)
int gzip_main(int argc, char ** argv)
{
int result;
int inFileNum;
int outFileNum;
struct stat statBuf;
char* delFileName;
int tostdout = 0;
int fromstdin = 0;
if (argc==1)
usage(gzip_usage);
/* Parse any options */
while (--argc > 0 && **(++argv) == '-') {
if (*((*argv)+1) == '\0') {
fromstdin = 1;
tostdout = 1;
}
while (*(++(*argv))) {
switch (**argv) {
case 'c':
tostdout = 1;
break;
default:
usage(gzip_usage);
}
}
}
foreground = signal(SIGINT, SIG_IGN) != SIG_IGN;
if (foreground) {
(void) signal (SIGINT, (sig_type)abort_gzip);
@@ -1789,8 +1816,6 @@ int gzip_main(int argc, char * * argv)
strncpy(z_suffix, Z_SUFFIX, sizeof(z_suffix)-1);
z_len = strlen(z_suffix);
to_stdout = 1;
/* Allocate all global buffers (for DYN_ALLOC option) */
ALLOC(uch, inbuf, INBUFSIZ +INBUF_EXTRA);
ALLOC(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA);
@@ -1803,33 +1828,88 @@ int gzip_main(int argc, char * * argv)
ALLOC(ush, tab_prefix1, 1L<<(BITS-1));
#endif
/* And get to work */
treat_stdin();
do_exit(exit_code);
return exit_code; /* just to avoid lint warning */
}
if (fromstdin==1) {
strcpy(ofname, "stdin");
/* ========================================================================
* Compress or decompress stdin
*/
local void treat_stdin()
{
inFileNum=fileno(stdin);
time_stamp = 0; /* time unknown by default */
ifile_size = -1L; /* convention for unknown size */
} else {
/* Open up the input file */
if (*argv=='\0')
usage(gzip_usage);
strncpy(ifname, *argv, MAX_PATH_LEN);
/* Open input fille */
inFileNum=open( ifname, O_RDONLY);
if (inFileNum < 0) {
perror(ifname);
do_exit(WARNING);
}
/* Get the time stamp on the input file. */
result = stat(ifname, &statBuf);
if (result < 0) {
perror(ifname);
do_exit(WARNING);
}
time_stamp = statBuf.st_ctime;
ifile_size = statBuf.st_size;
}
if (tostdout==1) {
/* And get to work */
strcpy(ofname, "stdout");
outFileNum=fileno(stdout);
SET_BINARY_MODE(fileno(stdout));
strcpy(ifname, "stdin");
strcpy(ofname, "stdout");
/* Get the time stamp on the input file. */
time_stamp = 0; /* time unknown by default */
clear_bufs(); /* clear input and output buffers */
part_nb = 0;
ifile_size = -1L; /* convention for unknown size */
/* Actually do the compression/decompression. */
zip(inFileNum, outFileNum);
clear_bufs(); /* clear input and output buffers */
to_stdout = 1;
part_nb = 0;
} else {
/* Actually do the compression/decompression. Loop over zipped members.
*/
if ((*work)(fileno(stdin), fileno(stdout)) != OK) return;
/* And get to work */
strncpy(ofname, ifname, MAX_PATH_LEN-4);
strcat(ofname, ".gz");
/* Open output fille */
#if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 1)
outFileNum=open( ofname, O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW);
#else
outFileNum=open( ofname, O_RDWR|O_CREAT|O_EXCL);
#endif
if (outFileNum < 0) {
perror(ofname);
do_exit(WARNING);
}
SET_BINARY_MODE(outFileNum);
/* Set permissions on the file */
fchmod(outFileNum, statBuf.st_mode);
clear_bufs(); /* clear input and output buffers */
part_nb = 0;
/* Actually do the compression/decompression. */
result=zip(inFileNum, outFileNum);
close( outFileNum);
close( inFileNum);
/* Delete the original file */
if (result == OK)
delFileName=ifname;
else
delFileName=ofname;
if (unlink (delFileName) < 0) {
perror (delFileName);
exit( FALSE);
}
}
do_exit(exit_code);
}
/* ========================================================================
@@ -2943,8 +3023,6 @@ local void set_file_type()
extern int errno;
#endif
extern ulg crc_32_tab[]; /* crc table, defined below */
/* ===========================================================================
* Copy input to output unchanged: zcat == cat with --force.
* IN assertion: insize bytes have already been read in inbuf.
@@ -3152,6 +3230,7 @@ int zip(in, out)
/* Write the header to the gzip file. See algorithm.doc for the format */
method = DEFLATED;
put_byte(GZIP_MAGIC[0]); /* magic header */
put_byte(GZIP_MAGIC[1]);
+2 -1
View File
@@ -26,6 +26,7 @@
extern int
halt_main(int argc, char ** argv)
{
exit( kill(1, SIGUSR1));
/* don't assume init's pid == 1 */
exit( kill(findInitPid(), SIGUSR1));
}
+106
View File
@@ -0,0 +1,106 @@
/*
* Mini head implementation for busybox
*
*
* Copyright (C) 1999 by Lineo, inc.
* Written by John Beppu <beppu@lineo.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <errno.h>
#include <stdio.h>
const char head_usage[] =
"Usage: head [FILE]...\n\n"
"Print first 10 lines of each FILE to standard output.\n"
"With more than one FILE, precede each with a header giving the\n"
"file name. With no FILE, or when FILE is -, read standard input.\n";
int
head(int len, FILE *src)
{
int i;
char buffer[1024];
for (i = 0; i < len; i++) {
fgets(buffer, 1024, src);
if (feof(src)) { break; }
fputs(buffer, stdout);
}
return 0;
}
/* BusyBoxed head(1) */
int
head_main(int argc, char **argv)
{
int i = 1;
char opt;
int len = 10;
/* 1st option is potentially special */
if ((argc > 1) && (argv[1][0] == '-') && isDecimal(argv[1][1])) {
int tmplen = atoi(&argv[1][1]);
if (tmplen) { len = tmplen; }
i = 2;
}
/* parse argv[] */
for ( ; i < argc; i++) {
if (argv[i][0] == '-') {
opt = argv[i][1];
switch (opt) {
case '-':
case 'h':
usage(head_usage);
default:
fprintf(stderr, "head: invalid option -- %c\n", opt);
usage(head_usage);
}
} else {
break;
}
}
/* get rest of argv[] or stdin if nothing's left */
if (i >= argc) {
head(len, stdin);
} else {
int need_headers = ((argc - i) > 1);
for ( ; i < argc; i++) {
FILE *src;
src = fopen(argv[i], "r");
if (!src) {
fprintf(stderr,"head: %s: %s\n", argv[i], strerror(errno));
} else {
/* emulating GNU behaviour */
if (need_headers) {
fprintf(stdout, "==> %s <==\n", argv[i]);
}
head(len, src);
if (i < argc - 1) {
fprintf(stdout, "\n");
}
}
}
}
exit(0);
}
/* $Id: head.c,v 1.4 1999/12/17 18:52:06 erik Exp $ */
+28
View File
@@ -0,0 +1,28 @@
/*
* Mini hostid implementation for busybox
*
* Copyright (C) 2000 Edward Betts <edward@debian.org>.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
extern int hostid_main(int argc, char **argv) {
printf ("%lx\n", gethostid());
exit( TRUE);
}
+138
View File
@@ -0,0 +1,138 @@
/*
* $Id: hostname.c,v 1.5 1999/12/09 06:11:36 andersen Exp $
* Mini hostname implementation for busybox
*
* Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
*
* adjusted by Erik Andersen <andersee@debian.org> to remove
* use of long options and GNU getopt. Improved the usage info.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "internal.h"
#include <errno.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <stdio.h>
static const char* hostname_usage =
"hostname [OPTION] {hostname | -F file}\n\n"
"Get or set the hostname or DNS domain name. If a hostname is given\n"
"(or a file with the -F parameter), the host name will be set.\n\n"
"Options:\n"
"\t-s\t\tShort\n"
"\t-i\t\tAddresses for the hostname\n"
"\t-d\t\tDNS domain name\n"
"\t-F FILE\t\tUse the contents of FILE to specify the hostname\n";
void do_sethostname(char *s, int isfile)
{
FILE *f;
char buf[255];
if (!s) return;
if (!isfile) {
if (sethostname(s, strlen(s)) < 0) {
if (errno == EPERM)
fprintf(stderr, "hostname: you must be root to change the hostname\n");
else
perror("sethostname");
exit(1);
}
} else {
if ((f = fopen(s, "r")) == NULL) {
perror(s);
exit(1);
} else {
fgets(buf, 255, f);
fclose(f);
if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = 0;
if (sethostname(buf, strlen(buf)) < 0) {
perror("sethostname");
exit(1);
}
}
}
}
int hostname_main(int argc, char **argv)
{
int opt_short = 0;
int opt_domain = 0;
int opt_ip = 0;
struct hostent *h;
char *filename = NULL;
char buf[255];
char *s = NULL;
if (argc < 1) usage(hostname_usage);
while (--argc > 0 && **(++argv) == '-') {
while (*(++(*argv))) {
switch (**argv) {
case 's':
opt_short = 1;
break;
case 'i':
opt_ip = 1;
break;
case 'd':
opt_domain = 1;
break;
case 'F':
filename = optarg;
if (--argc == 0) {
usage(hostname_usage);
}
filename = *(++argv);
break;
default:
usage(hostname_usage);
}
if (filename!=NULL)
break;
}
}
if (argc >= 1) {
do_sethostname(*argv, 0);
} else if (filename!=NULL) {
do_sethostname(filename, 1);
} else {
gethostname(buf, 255);
if (opt_short) {
s = strchr(buf, '.');
if (!s) s = buf; *s = 0;
printf("%s\n", buf);
} else if (opt_domain) {
s = strchr(buf, '.');
printf("%s\n", (s ? s+1 : ""));
} else if (opt_ip) {
h = gethostbyname(buf);
if (!h) {
printf("Host not found\n");
exit(1);
}
printf("%s\n", inet_ntoa(*(struct in_addr *)(h->h_addr)));
} else {
printf("%s\n", buf);
}
}
exit( 0);
}
+471 -164
View File
@@ -23,12 +23,14 @@
#include "internal.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <termios.h>
#include <paths.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#include <sys/wait.h>
@@ -40,23 +42,75 @@
#include <linux/serial.h> /* for serial_struct */
#include <sys/vt.h> /* for vt_stat */
#include <sys/ioctl.h>
#include <linux/version.h>
#ifdef BB_SYSLOGD
#include <sys/syslog.h>
#endif
#define VT_CONSOLE "/dev/console" /* Logical system console */
#define VT_PRIMARY "/dev/tty1" /* Primary virtual console */
#define VT_SECONDARY "/dev/tty2" /* Virtual console */
#define VT_LOG "/dev/tty3" /* Virtual console */
#define SERIAL_CON0 "/dev/ttyS0" /* Primary serial console */
#define SERIAL_CON1 "/dev/ttyS1" /* Serial console */
#define SHELL "/bin/sh" /* Default shell */
#define INITSCRIPT "/etc/init.d/rcS" /* Initscript. */
#define PATH_DEFAULT "PATH=/usr/local/sbin:/sbin:/bin:/usr/sbin:/usr/bin"
#if ! defined BB_FEATURE_USE_PROCFS
#error Sorry, I depend on the /proc filesystem right now.
#endif
#ifndef KERNEL_VERSION
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#endif
#define VT_PRIMARY "/dev/tty1" /* Primary virtual console */
#define VT_SECONDARY "/dev/tty2" /* Virtual console */
#define VT_LOG "/dev/tty3" /* Virtual console */
#define SERIAL_CON0 "/dev/ttyS0" /* Primary serial console */
#define SERIAL_CON1 "/dev/ttyS1" /* Serial console */
#define SHELL "/bin/sh" /* Default shell */
#define INITTAB "/etc/inittab" /* inittab file location */
#ifndef INIT_SCRIPT
#define INIT_SCRIPT "/etc/init.d/rcS" /* Default sysinit script. */
#endif
#define LOG 0x1
#define CONSOLE 0x2
static char *console = VT_CONSOLE;
static char *second_console = VT_SECONDARY;
static char *log = VT_LOG;
/* Allowed init action types */
typedef enum {
SYSINIT=1,
RESPAWN,
ASKFIRST,
WAIT,
ONCE
} initActionEnum;
/* And now a list of the actions we support in the version of init */
typedef struct initActionType{
const char* name;
initActionEnum action;
} initActionType;
static const struct initActionType actions[] = {
{"sysinit", SYSINIT},
{"respawn", RESPAWN},
{"askfirst", ASKFIRST},
{"wait", WAIT},
{"once", ONCE},
{0}
};
/* Set up a linked list of initactions, to be read from inittab */
typedef struct initActionTag initAction;
struct initActionTag {
pid_t pid;
char process[256];
char console[256];
initAction *nextPtr;
initActionEnum action;
};
initAction* initActionList = NULL;
static char *secondConsole = VT_SECONDARY;
static char *log = VT_LOG;
static int kernelVersion = 0;
static char termType[32] = "TERM=ansi";
static char console[32] = _PATH_CONSOLE;
/* try to open up the specified device */
@@ -82,28 +136,49 @@ int device_open(char *device, int mode)
* device may be bitwise-or'd from LOG | CONSOLE */
void message(int device, char *fmt, ...)
{
int fd;
static int log_fd=-1;
va_list arguments;
int fd;
#ifdef BB_SYSLOGD
/* Log the message to syslogd */
if (device & LOG ) {
char msg[1024];
va_start(arguments, fmt);
vsnprintf(msg, sizeof(msg), fmt, arguments);
va_end(arguments);
syslog(LOG_DAEMON|LOG_NOTICE, msg);
}
#else
static int log_fd=-1;
/* Take full control of the log tty, and never close it.
* It's mine, all mine! Muhahahaha! */
if (log_fd==-1) {
if ((log_fd = device_open(log, O_RDWR|O_NDELAY)) < 0) {
if (log_fd < 0) {
if (log == NULL) {
/* don't even try to log, because there is no such console */
log_fd = -2;
/* log to main console instead */
device = CONSOLE;
}
else if ((log_fd = device_open(log, O_RDWR|O_NDELAY)) < 0) {
log_fd=-1;
fprintf(stderr, "Bummer, can't write to log on %s!\r\n", log);
fflush(stderr);
return;
}
}
if ( (device & LOG) && (log_fd != -1) ) {
if ( (device & LOG) && (log_fd >= 0) ) {
va_start(arguments, fmt);
vdprintf(log_fd, fmt, arguments);
va_end(arguments);
}
#endif
if (device & CONSOLE) {
if ((fd = device_open(console, O_WRONLY|O_NOCTTY|O_NDELAY)) >= 0) {
/* Always send console messages to /dev/console so people will see them. */
if ((fd = device_open(_PATH_CONSOLE, O_WRONLY|O_NOCTTY|O_NDELAY)) >= 0) {
va_start(arguments, fmt);
vdprintf(fd, fmt, arguments);
va_end(arguments);
@@ -124,31 +199,31 @@ void set_term( int fd)
{
struct termios tty;
static const char control_characters[] = {
'\003', '\034', '\177', '\030', '\004', '\0',
'\003', '\034', '\177', '\025', '\004', '\0',
'\1', '\0', '\021', '\023', '\032', '\0', '\022',
'\017', '\027', '\026', '\0'
};
tcgetattr(fd, &tty);
/* Make it be sane */
tty.c_cflag &= CBAUD|CBAUDEX|CSIZE|CSTOPB|PARENB|PARODD;
tty.c_cflag |= HUPCL|CLOCAL;
/* input modes */
tty.c_iflag = IGNPAR|ICRNL|IXON|IXOFF|IXANY;
/* set control chars */
memcpy(tty.c_cc, control_characters, sizeof(control_characters));
/* use line dicipline 0 */
tty.c_line = 0;
/* Make it be sane */
//tty.c_cflag &= CBAUD|CBAUDEX|CSIZE|CSTOPB|PARENB|PARODD;
//tty.c_cflag |= HUPCL|CLOCAL;
/* input modes */
tty.c_iflag = ICRNL|IXON|IXOFF;
/* output modes */
tty.c_oflag = OPOST|ONLCR;
/* local modes */
tty.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOPRT|ECHOKE|IEXTEN;
/* control chars */
memcpy(tty.c_cc, control_characters, sizeof(control_characters));
tty.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN;
tcsetattr(fd, TCSANOW, &tty);
}
@@ -180,73 +255,97 @@ static void console_init()
int fd;
int tried_devcons = 0;
int tried_vtprimary = 0;
struct serial_struct sr;
char *s;
if ((s = getenv("TERM")) != NULL) {
snprintf(termType,sizeof(termType)-1,"TERM=%s",s);
}
if ((s = getenv("CONSOLE")) != NULL) {
console = s;
/* Apparently the sparc does wierd things... */
#if defined (__sparc__)
if (strncmp( s, "/dev/tty", 8 )==0) {
switch( s[8]) {
case 'a':
s=SERIAL_CON0;
break;
case 'b':
s=SERIAL_CON1;
}
}
snprintf(console, sizeof(console)-1, "%s",s);
}
#if #cpu(sparc)
/* sparc kernel supports console=tty[ab] parameter which is also
* passed to init, so catch it here */
else if ((s = getenv("console")) != NULL) {*/
/* remap tty[ab] to /dev/ttyS[01] */
if (strcmp( s, "ttya" )==0)
snprintf(console, sizeof(console)-1, "%s", SERIAL_CON0);
else if (strcmp( s, "ttyb" )==0)
snprintf(console, sizeof(console)-1, "%s", SERIAL_CON1);
}
#endif
} else {
console = VT_CONSOLE;
tried_devcons++;
else {
struct vt_stat vt;
/* 2.2 kernels: identify the real console backend and try to use it */
if (ioctl(0, TIOCGSERIAL, &sr) == 0) {
/* this is a serial console */
snprintf(console, sizeof(console)-1, "/dev/ttyS%d", sr.line);
}
else if (ioctl(0, VT_GETSTATE, &vt) == 0) {
/* this is linux virtual tty */
snprintf(console, sizeof(console)-1, "/dev/tty%d", vt.v_active);
} else {
snprintf(console, sizeof(console)-1, "%s", _PATH_CONSOLE);
tried_devcons++;
}
}
while ((fd = open(console, O_RDONLY | O_NONBLOCK)) < 0) {
/* Can't open selected console -- try /dev/console */
if (!tried_devcons) {
tried_devcons++;
console = VT_CONSOLE;
snprintf(console, sizeof(console)-1, "%s", _PATH_CONSOLE);
continue;
}
/* Can't open selected console -- try vt1 */
if (!tried_vtprimary) {
tried_vtprimary++;
console = VT_PRIMARY;
snprintf(console, sizeof(console)-1, "%s", VT_PRIMARY);
continue;
}
break;
}
if (fd < 0)
if (fd < 0) {
/* Perhaps we should panic here? */
console = "/dev/null";
else
snprintf(console, sizeof(console)-1, "/dev/null");
} else {
/* check for serial console and disable logging to tty3 & running a
* shell to tty2 */
if (ioctl(0,TIOCGSERIAL,&sr) == 0) {
message(LOG|CONSOLE, "serial console detected. Disabling virtual terminals.\r\n" );
log = NULL;
secondConsole = NULL;
}
close(fd);
}
message(LOG, "console=%s\n", console );
}
static int waitfor(int pid)
{
int status, wpid;
message(LOG, "Waiting for process %d.\n", pid);
while ((wpid = wait(&status)) != pid) {
if (wpid > 0)
message(LOG, "pid %d exited, status=0x%x.\n", wpid, status);
}
return wpid;
}
static pid_t run(const char * const* command,
static pid_t run(char* command,
char *terminal, int get_enter)
{
int fd;
int i, fd;
pid_t pid;
const char * const* cmd = command+1;
char* tmpCmd;
char* cmd[255];
static const char press_enter[] =
"\nPlease press Enter to activate this console. ";
char* environment[] = {
"HOME=/",
"PATH=/usr/bin:/bin:/usr/sbin:/sbin",
"SHELL=/bin/sh",
termType,
"USER=root",
0
};
if ((pid = fork()) == 0) {
pid_t shell_pgid = getpid ();
/* Clean up */
close(0);
close(1);
@@ -260,12 +359,12 @@ static pid_t run(const char * const* command,
signal(SIGTERM, SIG_DFL);
if ((fd = device_open(terminal, O_RDWR)) < 0) {
message(LOG, "Bummer, can't open %s\r\n", terminal);
exit(-1);
message(LOG|CONSOLE, "Bummer, can't open %s\r\n", terminal);
exit(1);
}
dup(fd);
dup(fd);
tcsetpgrp(0, getpgrp());
tcsetpgrp (0, getpgrp());
set_term(0);
if (get_enter==TRUE) {
@@ -279,40 +378,70 @@ static pid_t run(const char * const* command,
*/
char c;
message(LOG, "Waiting for enter to start '%s' (pid %d, console %s)\r\n",
*cmd, getpid(), terminal );
write(1, press_enter, sizeof(press_enter) - 1);
read(0, &c, 1);
command, shell_pgid, terminal );
write(fileno(stdout), press_enter, sizeof(press_enter) - 1);
read(fileno(stdin), &c, 1);
}
/* Log the process name and args */
message(LOG, "Starting pid %d, console %s: '", getpid(), terminal);
while ( *cmd) message(LOG, "%s ", *cmd++);
message(LOG, "Starting pid %d, console %s: '",
shell_pgid, terminal, command);
/* Convert command (char*) into cmd (char**, one word per string) */
for (tmpCmd=command, i=0; (tmpCmd=strsep(&command, " \t")) != NULL;) {
if (*tmpCmd != '\0') {
cmd[i] = tmpCmd;
message(LOG, "%s ", tmpCmd);
tmpCmd++;
i++;
}
}
cmd[i] = NULL;
message(LOG, "'\r\n");
/* Now run it. The new program will take over this PID,
* so nothing further in init.c should be run. */
execvp(*command, (char**)command+1);
execve(cmd[0], cmd, environment);
message(LOG, "Bummer, could not run '%s'\n", command);
/* We're still here? Some error happened. */
message(LOG|CONSOLE, "Bummer, could not run '%s': %s\n", cmd[0],
strerror(errno));
exit(-1);
}
return pid;
}
static int waitfor(char* command,
char *terminal, int get_enter)
{
int status, wpid;
int pid = run( command, terminal, get_enter);
while (1) {
wpid = wait(&status);
if (wpid > 0 ) {
message(LOG, "Process '%s' (pid %d) exited.\n",
command, wpid);
break;
}
if (wpid == pid )
break;
}
return wpid;
}
/* Make sure there is enough memory to do something useful. *
* Calls swapon if needed so be sure /proc is mounted. */
static void check_memory()
{
struct stat statbuf;
const char* const swap_on_cmd[] =
{ "/bin/swapon", "swapon", "-a", 0};
struct stat statBuf;
if (mem_total() > 3500)
return;
if (stat("/etc/fstab", &statbuf) == 0) {
if (stat("/etc/fstab", &statBuf) == 0) {
/* Try to turn on swap */
waitfor(run(swap_on_cmd, log, FALSE));
waitfor("/bin/swapon swapon -a", log, FALSE);
if (mem_total() < 3500)
goto goodnight;
} else
@@ -324,34 +453,30 @@ goodnight:
while (1) sleep(1);
}
#ifndef DEBUG_INIT
static void shutdown_system(void)
{
const char* const swap_off_cmd[] = { "swapoff", "swapoff", "-a", 0};
const char* const umount_cmd[] = { "umount", "umount", "-a", "-n", 0};
#ifndef DEBUG_INIT
/* Allow Ctrl-Alt-Del to reboot system. */
reboot(RB_ENABLE_CAD);
#endif
message(CONSOLE, "The system is going down NOW !!\r\n");
message(CONSOLE, "\r\nThe system is going down NOW !!\r\n");
sync();
/* Send signals to every process _except_ pid 1 */
message(CONSOLE, "Sending SIGHUP to all processes.\r\n");
#ifndef DEBUG_INIT
kill(-1, SIGHUP);
#endif
sleep(2);
sync();
message(CONSOLE, "Sending SIGKILL to all processes.\r\n");
#ifndef DEBUG_INIT
kill(-1, SIGKILL);
#endif
sleep(1);
waitfor(run( swap_off_cmd, console, FALSE));
waitfor(run( umount_cmd, console, FALSE));
message(CONSOLE, "Disabling swap.\r\n");
waitfor( "swapoff -a", console, FALSE);
message(CONSOLE, "Unmounting filesystems.\r\n");
waitfor("umount -a", console, FALSE);
sync();
message(CONSOLE, "Skipping bdflush\r\n");
if (get_kernel_revision() <= 2 * 65536 + 2 * 256 + 11) {
if (kernelVersion > 0 && kernelVersion <= 2 * 65536 + 2 * 256 + 11) {
/* bdflush, kupdate not needed for kernels >2.2.11 */
bdflush(1, 0);
sync();
@@ -364,10 +489,12 @@ static void halt_signal(int sig)
message(CONSOLE,
"The system is halted. Press CTRL-ALT-DEL or turn off power\r\n");
sync();
#ifndef DEBUG_INIT
reboot(RB_HALT_SYSTEM);
//reboot(RB_POWER_OFF);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
if (sig == SIGUSR2)
reboot(RB_POWER_OFF);
else
#endif
reboot(RB_HALT_SYSTEM);
exit(0);
}
@@ -376,39 +503,173 @@ static void reboot_signal(int sig)
shutdown_system();
message(CONSOLE, "Please stand by while rebooting the system.\r\n");
sync();
#ifndef DEBUG_INIT
reboot(RB_AUTOBOOT);
#endif
exit(0);
}
#endif
void new_initAction (initActionEnum action,
char* process, char* cons)
{
initAction* newAction;
/* If BusyBox detects that a serial console is in use,
* then entries containing non-empty id fields will _not_ be run.
*/
if (secondConsole == NULL && *cons != '\0') {
return;
}
newAction = calloc ((size_t)(1), sizeof(initAction));
if (!newAction) {
message(LOG|CONSOLE,"Memory allocation failure\n");
while (1) sleep(1);
}
newAction->nextPtr = initActionList;
initActionList = newAction;
strncpy( newAction->process, process, 255);
newAction->action = action;
if (*cons != '\0') {
strncpy(newAction->console, cons, 255);
} else
strncpy(newAction->console, console, 255);
newAction->pid = 0;
// message(LOG|CONSOLE, "process='%s' action='%d' console='%s'\n",
// newAction->process, newAction->action, newAction->console);
}
void delete_initAction (initAction *action)
{
initAction *a, *b=NULL;
for( a=initActionList ; a; b=a, a=a->nextPtr) {
if (a == action && b != NULL) {
b->nextPtr=a->nextPtr;
free( a);
break;
}
}
}
/* NOTE that if BB_FEATURE_USE_INITTAB is NOT defined,
* then parse_inittab() simply adds in some default
* actions(i.e runs INIT_SCRIPT and then starts a pair
* of "askfirst" shells). If BB_FEATURE_USE_INITTAB
* _is_ defined, but /etc/inittab is missing, this
* results in the same set of default behaviors.
* */
void parse_inittab(void)
{
#ifdef BB_FEATURE_USE_INITTAB
FILE* file;
char buf[256], lineAsRead[256], tmpConsole[256];
char *p, *q, *r, *s;
const struct initActionType *a = actions;
int foundIt;
file = fopen(INITTAB, "r");
if (file == NULL) {
/* No inittab file -- set up some default behavior */
#endif
/* Askfirst shell on tty1 */
new_initAction( ASKFIRST, SHELL, console );
/* Askfirst shell on tty2 */
if (secondConsole != NULL)
new_initAction( ASKFIRST, SHELL, secondConsole );
/* sysinit */
new_initAction( SYSINIT, INIT_SCRIPT, console );
return;
#ifdef BB_FEATURE_USE_INITTAB
}
while ( fgets(buf, 255, file) != NULL) {
foundIt=FALSE;
for(p = buf; *p == ' ' || *p == '\t'; p++);
if (*p == '#' || *p == '\n') continue;
/* Trim the trailing \n */
q = strrchr( p, '\n');
if (q != NULL)
*q='\0';
/* Keep a copy around for posterity's sake (and error msgs) */
strcpy(lineAsRead, buf);
/* Grab the ID field */
s=p;
p = strchr( p, ':');
if ( p != NULL || *(p+1) != '\0' ) {
*p='\0';
++p;
}
/* Now peal off the process field from the end
* of the string */
q = strrchr( p, ':');
if ( q == NULL || *(q+1) == '\0' ) {
message(LOG|CONSOLE,"Bad inittab entry: %s\n", lineAsRead);
continue;
} else {
*q='\0';
++q;
}
/* Now peal off the action field */
r = strrchr( p, ':');
if ( r == NULL || *(r+1) == '\0') {
message(LOG|CONSOLE,"Bad inittab entry: %s\n", lineAsRead);
continue;
} else {
++r;
}
/* Ok, now process it */
a = actions;
while (a->name != 0) {
if (strcmp(a->name, r) == 0) {
if (*s != '\0') {
struct stat statBuf;
strcpy(tmpConsole, "/dev/");
strncat(tmpConsole, s, 200);
if (stat(tmpConsole, &statBuf) != 0) {
message(LOG|CONSOLE, "device '%s' does not exist. Did you read the directions?\n", tmpConsole);
break;
}
s = tmpConsole;
}
new_initAction( a->action, q, s);
foundIt=TRUE;
}
a++;
}
if (foundIt==TRUE)
continue;
else {
/* Choke on an unknown action */
message(LOG|CONSOLE, "Bad inittab entry: %s\n", lineAsRead);
}
}
return;
#endif
}
extern int init_main(int argc, char **argv)
{
int run_rc = TRUE;
int wait_for_enter = TRUE;
pid_t pid1 = 0;
pid_t pid2 = 0;
struct stat statbuf;
const char* const init_commands[] = { INITSCRIPT, INITSCRIPT, 0};
const char* const shell_commands[] = { SHELL, "-" SHELL, 0};
const char* const* tty0_commands = shell_commands;
const char* const* tty1_commands = shell_commands;
#ifdef DEBUG_INIT
char *hello_msg_format =
"init(%d) started: BusyBox v%s (%s) multi-call binary\r\n";
#else
char *hello_msg_format =
"init started: BusyBox v%s (%s) multi-call binary\r\n";
#endif
initAction *a;
pid_t wpid;
int status;
/* Check if we are supposed to be in single user mode */
if ( argc > 1 && (!strcmp(argv[1], "single") ||
!strcmp(argv[1], "-s") || !strcmp(argv[1], "1"))) {
run_rc = FALSE;
#ifndef DEBUG_INIT
/* Expect to be PID 1 iff we are run as init (not linuxrc) */
if (getpid() != 1 && strstr(argv[0], "init")!=NULL ) {
usage( "init\n\nInit is the parent of all processes.\n\n"
"This version of init is designed to be run only by the kernel\n");
}
/* Fix up argv[0] to be certain we claim to be init */
strncpy(argv[0], "init", strlen(argv[0]));
/* Set up sig handlers -- be sure to
* clear all of these in run() */
signal(SIGUSR1, halt_signal);
@@ -418,7 +679,6 @@ extern int init_main(int argc, char **argv)
/* Turn off rebooting via CTL-ALT-DEL -- we get a
* SIGINT on CAD so we can shut things down gracefully... */
#ifndef DEBUG_INIT
reboot(RB_DISABLE_CAD);
#endif
@@ -433,68 +693,115 @@ extern int init_main(int argc, char **argv)
setsid();
/* Make sure PATH is set to something sane */
putenv(PATH_DEFAULT);
putenv(_PATH_STDPATH);
/* Hello world */
#ifndef DEBUG_INIT
message(CONSOLE|LOG, hello_msg_format, BB_VER, BB_BT);
message(LOG|CONSOLE,
"init started: BusyBox v%s (%s) multi-call binary\r\n",
BB_VER, BB_BT);
#else
message(CONSOLE|LOG, hello_msg_format, getpid(), BB_VER, BB_BT);
message(LOG|CONSOLE,
"init(%d) started: BusyBox v%s (%s) multi-call binary\r\n",
getpid(), BB_VER, BB_BT);
#endif
/* Mount /proc */
if (mount ("proc", "/proc", "proc", 0, 0) == 0)
message(CONSOLE|LOG, "Mounting /proc: done.\n");
else
message(CONSOLE|LOG, "Mounting /proc: failed!\n");
if (mount ("proc", "/proc", "proc", 0, 0) == 0) {
message(LOG|CONSOLE, "Mounting /proc: done.\n");
kernelVersion = get_kernel_revision();
} else
message(LOG|CONSOLE, "Mounting /proc: failed!\n");
/* Make sure there is enough memory to do something useful. */
check_memory();
/* Check if we are supposed to be in single user mode */
if ( argc > 1 && (!strcmp(argv[1], "single") ||
!strcmp(argv[1], "-s") || !strcmp(argv[1], "1")))
{
/* Ask first then start a shell on tty2 */
if (secondConsole != NULL)
new_initAction( ASKFIRST, SHELL, secondConsole);
/* Ask first then start a shell on tty1 */
new_initAction( ASKFIRST, SHELL, console);
} else {
/* Not in single user mode -- see what inittab says */
/* Make sure an init script exists before trying to run it */
if (run_rc == TRUE && stat(INITSCRIPT, &statbuf)==0) {
wait_for_enter = FALSE;
tty0_commands = init_commands;
/* NOTE that if BB_FEATURE_USE_INITTAB is NOT defined,
* then parse_inittab() simply adds in some default
* actions(i.e runs INIT_SCRIPT and then starts a pair
* of "askfirst" shells */
parse_inittab();
}
/* Now run everything that needs to be run */
/* Ok, now launch the rc script and/or prepare to
* start up some VTs if somebody hits enter...
*/
for (;;) {
pid_t wpid;
int status;
/* First run the sysinit command */
for( a=initActionList ; a; a=a->nextPtr) {
if (a->action == SYSINIT) {
waitfor(a->process, a->console, FALSE);
/* Now remove the "sysinit" entry from the list */
delete_initAction( a);
}
}
/* Next run anything that wants to block */
for( a=initActionList ; a; a=a->nextPtr) {
if (a->action == WAIT) {
waitfor(a->process, a->console, FALSE);
/* Now remove the "wait" entry from the list */
delete_initAction( a);
}
}
/* Next run anything to be run only once */
for( a=initActionList ; a; a=a->nextPtr) {
if (a->action == ONCE) {
run(a->process, a->console, FALSE);
/* Now remove the "once" entry from the list */
delete_initAction( a);
}
}
/* If there is nothing else to do, stop */
if (initActionList == NULL) {
message(LOG|CONSOLE, "No more tasks for init -- sleeping forever.\n");
while (1) sleep(1);
}
if (pid1 == 0 && tty0_commands) {
pid1 = run(tty0_commands, console, wait_for_enter);
}
if (pid2 == 0 && tty1_commands) {
pid2 = run(tty1_commands, second_console, TRUE);
/* Now run the looping stuff for the rest of forever */
while (1) {
for( a=initActionList ; a; a=a->nextPtr) {
/* Only run stuff with pid==0. If they have
* a pid, that means they are still running */
if (a->pid == 0) {
switch(a->action) {
case RESPAWN:
/* run the respawn stuff */
a->pid = run(a->process, a->console, FALSE);
break;
case ASKFIRST:
/* run the askfirst stuff */
a->pid = run(a->process, a->console, TRUE);
break;
/* silence the compiler's incessant whining */
default:
break;
}
}
}
/* Wait for a child process to exit */
wpid = wait(&status);
if (wpid > 0 ) {
message(LOG, "pid %d exited, status=%x.\n", wpid, status);
}
/* Don't respawn init script if it exits */
if (wpid == pid1) {
if (run_rc == FALSE) {
pid1 = 0;
}
#if 0
/* Turn this on to start a shell on the console if the init script exits.... */
else {
run_rc=FALSE;
wait_for_enter=TRUE;
tty0_commands=shell_commands;
/* Find out who died and clean up their corpse */
for( a=initActionList ; a; a=a->nextPtr) {
if (a->pid==wpid) {
a->pid=0;
message(LOG, "Process '%s' (pid %d) exited. Scheduling it for restart.\n",
a->process, wpid);
}
}
#endif
}
if (wpid == pid2) {
pid2 = 0;
}
sleep(1);
}
}
+2 -1
View File
@@ -26,6 +26,7 @@
extern int
halt_main(int argc, char ** argv)
{
exit( kill(1, SIGUSR1));
/* don't assume init's pid == 1 */
exit( kill(findInitPid(), SIGUSR1));
}
+471 -164
View File
@@ -23,12 +23,14 @@
#include "internal.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <termios.h>
#include <paths.h>
#include <sys/types.h>
#include <sys/fcntl.h>
#include <sys/wait.h>
@@ -40,23 +42,75 @@
#include <linux/serial.h> /* for serial_struct */
#include <sys/vt.h> /* for vt_stat */
#include <sys/ioctl.h>
#include <linux/version.h>
#ifdef BB_SYSLOGD
#include <sys/syslog.h>
#endif
#define VT_CONSOLE "/dev/console" /* Logical system console */
#define VT_PRIMARY "/dev/tty1" /* Primary virtual console */
#define VT_SECONDARY "/dev/tty2" /* Virtual console */
#define VT_LOG "/dev/tty3" /* Virtual console */
#define SERIAL_CON0 "/dev/ttyS0" /* Primary serial console */
#define SERIAL_CON1 "/dev/ttyS1" /* Serial console */
#define SHELL "/bin/sh" /* Default shell */
#define INITSCRIPT "/etc/init.d/rcS" /* Initscript. */
#define PATH_DEFAULT "PATH=/usr/local/sbin:/sbin:/bin:/usr/sbin:/usr/bin"
#if ! defined BB_FEATURE_USE_PROCFS
#error Sorry, I depend on the /proc filesystem right now.
#endif
#ifndef KERNEL_VERSION
#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#endif
#define VT_PRIMARY "/dev/tty1" /* Primary virtual console */
#define VT_SECONDARY "/dev/tty2" /* Virtual console */
#define VT_LOG "/dev/tty3" /* Virtual console */
#define SERIAL_CON0 "/dev/ttyS0" /* Primary serial console */
#define SERIAL_CON1 "/dev/ttyS1" /* Serial console */
#define SHELL "/bin/sh" /* Default shell */
#define INITTAB "/etc/inittab" /* inittab file location */
#ifndef INIT_SCRIPT
#define INIT_SCRIPT "/etc/init.d/rcS" /* Default sysinit script. */
#endif
#define LOG 0x1
#define CONSOLE 0x2
static char *console = VT_CONSOLE;
static char *second_console = VT_SECONDARY;
static char *log = VT_LOG;
/* Allowed init action types */
typedef enum {
SYSINIT=1,
RESPAWN,
ASKFIRST,
WAIT,
ONCE
} initActionEnum;
/* And now a list of the actions we support in the version of init */
typedef struct initActionType{
const char* name;
initActionEnum action;
} initActionType;
static const struct initActionType actions[] = {
{"sysinit", SYSINIT},
{"respawn", RESPAWN},
{"askfirst", ASKFIRST},
{"wait", WAIT},
{"once", ONCE},
{0}
};
/* Set up a linked list of initactions, to be read from inittab */
typedef struct initActionTag initAction;
struct initActionTag {
pid_t pid;
char process[256];
char console[256];
initAction *nextPtr;
initActionEnum action;
};
initAction* initActionList = NULL;
static char *secondConsole = VT_SECONDARY;
static char *log = VT_LOG;
static int kernelVersion = 0;
static char termType[32] = "TERM=ansi";
static char console[32] = _PATH_CONSOLE;
/* try to open up the specified device */
@@ -82,28 +136,49 @@ int device_open(char *device, int mode)
* device may be bitwise-or'd from LOG | CONSOLE */
void message(int device, char *fmt, ...)
{
int fd;
static int log_fd=-1;
va_list arguments;
int fd;
#ifdef BB_SYSLOGD
/* Log the message to syslogd */
if (device & LOG ) {
char msg[1024];
va_start(arguments, fmt);
vsnprintf(msg, sizeof(msg), fmt, arguments);
va_end(arguments);
syslog(LOG_DAEMON|LOG_NOTICE, msg);
}
#else
static int log_fd=-1;
/* Take full control of the log tty, and never close it.
* It's mine, all mine! Muhahahaha! */
if (log_fd==-1) {
if ((log_fd = device_open(log, O_RDWR|O_NDELAY)) < 0) {
if (log_fd < 0) {
if (log == NULL) {
/* don't even try to log, because there is no such console */
log_fd = -2;
/* log to main console instead */
device = CONSOLE;
}
else if ((log_fd = device_open(log, O_RDWR|O_NDELAY)) < 0) {
log_fd=-1;
fprintf(stderr, "Bummer, can't write to log on %s!\r\n", log);
fflush(stderr);
return;
}
}
if ( (device & LOG) && (log_fd != -1) ) {
if ( (device & LOG) && (log_fd >= 0) ) {
va_start(arguments, fmt);
vdprintf(log_fd, fmt, arguments);
va_end(arguments);
}
#endif
if (device & CONSOLE) {
if ((fd = device_open(console, O_WRONLY|O_NOCTTY|O_NDELAY)) >= 0) {
/* Always send console messages to /dev/console so people will see them. */
if ((fd = device_open(_PATH_CONSOLE, O_WRONLY|O_NOCTTY|O_NDELAY)) >= 0) {
va_start(arguments, fmt);
vdprintf(fd, fmt, arguments);
va_end(arguments);
@@ -124,31 +199,31 @@ void set_term( int fd)
{
struct termios tty;
static const char control_characters[] = {
'\003', '\034', '\177', '\030', '\004', '\0',
'\003', '\034', '\177', '\025', '\004', '\0',
'\1', '\0', '\021', '\023', '\032', '\0', '\022',
'\017', '\027', '\026', '\0'
};
tcgetattr(fd, &tty);
/* Make it be sane */
tty.c_cflag &= CBAUD|CBAUDEX|CSIZE|CSTOPB|PARENB|PARODD;
tty.c_cflag |= HUPCL|CLOCAL;
/* input modes */
tty.c_iflag = IGNPAR|ICRNL|IXON|IXOFF|IXANY;
/* set control chars */
memcpy(tty.c_cc, control_characters, sizeof(control_characters));
/* use line dicipline 0 */
tty.c_line = 0;
/* Make it be sane */
//tty.c_cflag &= CBAUD|CBAUDEX|CSIZE|CSTOPB|PARENB|PARODD;
//tty.c_cflag |= HUPCL|CLOCAL;
/* input modes */
tty.c_iflag = ICRNL|IXON|IXOFF;
/* output modes */
tty.c_oflag = OPOST|ONLCR;
/* local modes */
tty.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOPRT|ECHOKE|IEXTEN;
/* control chars */
memcpy(tty.c_cc, control_characters, sizeof(control_characters));
tty.c_lflag = ISIG|ICANON|ECHO|ECHOE|ECHOK|ECHOCTL|ECHOKE|IEXTEN;
tcsetattr(fd, TCSANOW, &tty);
}
@@ -180,73 +255,97 @@ static void console_init()
int fd;
int tried_devcons = 0;
int tried_vtprimary = 0;
struct serial_struct sr;
char *s;
if ((s = getenv("TERM")) != NULL) {
snprintf(termType,sizeof(termType)-1,"TERM=%s",s);
}
if ((s = getenv("CONSOLE")) != NULL) {
console = s;
/* Apparently the sparc does wierd things... */
#if defined (__sparc__)
if (strncmp( s, "/dev/tty", 8 )==0) {
switch( s[8]) {
case 'a':
s=SERIAL_CON0;
break;
case 'b':
s=SERIAL_CON1;
}
}
snprintf(console, sizeof(console)-1, "%s",s);
}
#if #cpu(sparc)
/* sparc kernel supports console=tty[ab] parameter which is also
* passed to init, so catch it here */
else if ((s = getenv("console")) != NULL) {*/
/* remap tty[ab] to /dev/ttyS[01] */
if (strcmp( s, "ttya" )==0)
snprintf(console, sizeof(console)-1, "%s", SERIAL_CON0);
else if (strcmp( s, "ttyb" )==0)
snprintf(console, sizeof(console)-1, "%s", SERIAL_CON1);
}
#endif
} else {
console = VT_CONSOLE;
tried_devcons++;
else {
struct vt_stat vt;
/* 2.2 kernels: identify the real console backend and try to use it */
if (ioctl(0, TIOCGSERIAL, &sr) == 0) {
/* this is a serial console */
snprintf(console, sizeof(console)-1, "/dev/ttyS%d", sr.line);
}
else if (ioctl(0, VT_GETSTATE, &vt) == 0) {
/* this is linux virtual tty */
snprintf(console, sizeof(console)-1, "/dev/tty%d", vt.v_active);
} else {
snprintf(console, sizeof(console)-1, "%s", _PATH_CONSOLE);
tried_devcons++;
}
}
while ((fd = open(console, O_RDONLY | O_NONBLOCK)) < 0) {
/* Can't open selected console -- try /dev/console */
if (!tried_devcons) {
tried_devcons++;
console = VT_CONSOLE;
snprintf(console, sizeof(console)-1, "%s", _PATH_CONSOLE);
continue;
}
/* Can't open selected console -- try vt1 */
if (!tried_vtprimary) {
tried_vtprimary++;
console = VT_PRIMARY;
snprintf(console, sizeof(console)-1, "%s", VT_PRIMARY);
continue;
}
break;
}
if (fd < 0)
if (fd < 0) {
/* Perhaps we should panic here? */
console = "/dev/null";
else
snprintf(console, sizeof(console)-1, "/dev/null");
} else {
/* check for serial console and disable logging to tty3 & running a
* shell to tty2 */
if (ioctl(0,TIOCGSERIAL,&sr) == 0) {
message(LOG|CONSOLE, "serial console detected. Disabling virtual terminals.\r\n" );
log = NULL;
secondConsole = NULL;
}
close(fd);
}
message(LOG, "console=%s\n", console );
}
static int waitfor(int pid)
{
int status, wpid;
message(LOG, "Waiting for process %d.\n", pid);
while ((wpid = wait(&status)) != pid) {
if (wpid > 0)
message(LOG, "pid %d exited, status=0x%x.\n", wpid, status);
}
return wpid;
}
static pid_t run(const char * const* command,
static pid_t run(char* command,
char *terminal, int get_enter)
{
int fd;
int i, fd;
pid_t pid;
const char * const* cmd = command+1;
char* tmpCmd;
char* cmd[255];
static const char press_enter[] =
"\nPlease press Enter to activate this console. ";
char* environment[] = {
"HOME=/",
"PATH=/usr/bin:/bin:/usr/sbin:/sbin",
"SHELL=/bin/sh",
termType,
"USER=root",
0
};
if ((pid = fork()) == 0) {
pid_t shell_pgid = getpid ();
/* Clean up */
close(0);
close(1);
@@ -260,12 +359,12 @@ static pid_t run(const char * const* command,
signal(SIGTERM, SIG_DFL);
if ((fd = device_open(terminal, O_RDWR)) < 0) {
message(LOG, "Bummer, can't open %s\r\n", terminal);
exit(-1);
message(LOG|CONSOLE, "Bummer, can't open %s\r\n", terminal);
exit(1);
}
dup(fd);
dup(fd);
tcsetpgrp(0, getpgrp());
tcsetpgrp (0, getpgrp());
set_term(0);
if (get_enter==TRUE) {
@@ -279,40 +378,70 @@ static pid_t run(const char * const* command,
*/
char c;
message(LOG, "Waiting for enter to start '%s' (pid %d, console %s)\r\n",
*cmd, getpid(), terminal );
write(1, press_enter, sizeof(press_enter) - 1);
read(0, &c, 1);
command, shell_pgid, terminal );
write(fileno(stdout), press_enter, sizeof(press_enter) - 1);
read(fileno(stdin), &c, 1);
}
/* Log the process name and args */
message(LOG, "Starting pid %d, console %s: '", getpid(), terminal);
while ( *cmd) message(LOG, "%s ", *cmd++);
message(LOG, "Starting pid %d, console %s: '",
shell_pgid, terminal, command);
/* Convert command (char*) into cmd (char**, one word per string) */
for (tmpCmd=command, i=0; (tmpCmd=strsep(&command, " \t")) != NULL;) {
if (*tmpCmd != '\0') {
cmd[i] = tmpCmd;
message(LOG, "%s ", tmpCmd);
tmpCmd++;
i++;
}
}
cmd[i] = NULL;
message(LOG, "'\r\n");
/* Now run it. The new program will take over this PID,
* so nothing further in init.c should be run. */
execvp(*command, (char**)command+1);
execve(cmd[0], cmd, environment);
message(LOG, "Bummer, could not run '%s'\n", command);
/* We're still here? Some error happened. */
message(LOG|CONSOLE, "Bummer, could not run '%s': %s\n", cmd[0],
strerror(errno));
exit(-1);
}
return pid;
}
static int waitfor(char* command,
char *terminal, int get_enter)
{
int status, wpid;
int pid = run( command, terminal, get_enter);
while (1) {
wpid = wait(&status);
if (wpid > 0 ) {
message(LOG, "Process '%s' (pid %d) exited.\n",
command, wpid);
break;
}
if (wpid == pid )
break;
}
return wpid;
}
/* Make sure there is enough memory to do something useful. *
* Calls swapon if needed so be sure /proc is mounted. */
static void check_memory()
{
struct stat statbuf;
const char* const swap_on_cmd[] =
{ "/bin/swapon", "swapon", "-a", 0};
struct stat statBuf;
if (mem_total() > 3500)
return;
if (stat("/etc/fstab", &statbuf) == 0) {
if (stat("/etc/fstab", &statBuf) == 0) {
/* Try to turn on swap */
waitfor(run(swap_on_cmd, log, FALSE));
waitfor("/bin/swapon swapon -a", log, FALSE);
if (mem_total() < 3500)
goto goodnight;
} else
@@ -324,34 +453,30 @@ goodnight:
while (1) sleep(1);
}
#ifndef DEBUG_INIT
static void shutdown_system(void)
{
const char* const swap_off_cmd[] = { "swapoff", "swapoff", "-a", 0};
const char* const umount_cmd[] = { "umount", "umount", "-a", "-n", 0};
#ifndef DEBUG_INIT
/* Allow Ctrl-Alt-Del to reboot system. */
reboot(RB_ENABLE_CAD);
#endif
message(CONSOLE, "The system is going down NOW !!\r\n");
message(CONSOLE, "\r\nThe system is going down NOW !!\r\n");
sync();
/* Send signals to every process _except_ pid 1 */
message(CONSOLE, "Sending SIGHUP to all processes.\r\n");
#ifndef DEBUG_INIT
kill(-1, SIGHUP);
#endif
sleep(2);
sync();
message(CONSOLE, "Sending SIGKILL to all processes.\r\n");
#ifndef DEBUG_INIT
kill(-1, SIGKILL);
#endif
sleep(1);
waitfor(run( swap_off_cmd, console, FALSE));
waitfor(run( umount_cmd, console, FALSE));
message(CONSOLE, "Disabling swap.\r\n");
waitfor( "swapoff -a", console, FALSE);
message(CONSOLE, "Unmounting filesystems.\r\n");
waitfor("umount -a", console, FALSE);
sync();
message(CONSOLE, "Skipping bdflush\r\n");
if (get_kernel_revision() <= 2 * 65536 + 2 * 256 + 11) {
if (kernelVersion > 0 && kernelVersion <= 2 * 65536 + 2 * 256 + 11) {
/* bdflush, kupdate not needed for kernels >2.2.11 */
bdflush(1, 0);
sync();
@@ -364,10 +489,12 @@ static void halt_signal(int sig)
message(CONSOLE,
"The system is halted. Press CTRL-ALT-DEL or turn off power\r\n");
sync();
#ifndef DEBUG_INIT
reboot(RB_HALT_SYSTEM);
//reboot(RB_POWER_OFF);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0)
if (sig == SIGUSR2)
reboot(RB_POWER_OFF);
else
#endif
reboot(RB_HALT_SYSTEM);
exit(0);
}
@@ -376,39 +503,173 @@ static void reboot_signal(int sig)
shutdown_system();
message(CONSOLE, "Please stand by while rebooting the system.\r\n");
sync();
#ifndef DEBUG_INIT
reboot(RB_AUTOBOOT);
#endif
exit(0);
}
#endif
void new_initAction (initActionEnum action,
char* process, char* cons)
{
initAction* newAction;
/* If BusyBox detects that a serial console is in use,
* then entries containing non-empty id fields will _not_ be run.
*/
if (secondConsole == NULL && *cons != '\0') {
return;
}
newAction = calloc ((size_t)(1), sizeof(initAction));
if (!newAction) {
message(LOG|CONSOLE,"Memory allocation failure\n");
while (1) sleep(1);
}
newAction->nextPtr = initActionList;
initActionList = newAction;
strncpy( newAction->process, process, 255);
newAction->action = action;
if (*cons != '\0') {
strncpy(newAction->console, cons, 255);
} else
strncpy(newAction->console, console, 255);
newAction->pid = 0;
// message(LOG|CONSOLE, "process='%s' action='%d' console='%s'\n",
// newAction->process, newAction->action, newAction->console);
}
void delete_initAction (initAction *action)
{
initAction *a, *b=NULL;
for( a=initActionList ; a; b=a, a=a->nextPtr) {
if (a == action && b != NULL) {
b->nextPtr=a->nextPtr;
free( a);
break;
}
}
}
/* NOTE that if BB_FEATURE_USE_INITTAB is NOT defined,
* then parse_inittab() simply adds in some default
* actions(i.e runs INIT_SCRIPT and then starts a pair
* of "askfirst" shells). If BB_FEATURE_USE_INITTAB
* _is_ defined, but /etc/inittab is missing, this
* results in the same set of default behaviors.
* */
void parse_inittab(void)
{
#ifdef BB_FEATURE_USE_INITTAB
FILE* file;
char buf[256], lineAsRead[256], tmpConsole[256];
char *p, *q, *r, *s;
const struct initActionType *a = actions;
int foundIt;
file = fopen(INITTAB, "r");
if (file == NULL) {
/* No inittab file -- set up some default behavior */
#endif
/* Askfirst shell on tty1 */
new_initAction( ASKFIRST, SHELL, console );
/* Askfirst shell on tty2 */
if (secondConsole != NULL)
new_initAction( ASKFIRST, SHELL, secondConsole );
/* sysinit */
new_initAction( SYSINIT, INIT_SCRIPT, console );
return;
#ifdef BB_FEATURE_USE_INITTAB
}
while ( fgets(buf, 255, file) != NULL) {
foundIt=FALSE;
for(p = buf; *p == ' ' || *p == '\t'; p++);
if (*p == '#' || *p == '\n') continue;
/* Trim the trailing \n */
q = strrchr( p, '\n');
if (q != NULL)
*q='\0';
/* Keep a copy around for posterity's sake (and error msgs) */
strcpy(lineAsRead, buf);
/* Grab the ID field */
s=p;
p = strchr( p, ':');
if ( p != NULL || *(p+1) != '\0' ) {
*p='\0';
++p;
}
/* Now peal off the process field from the end
* of the string */
q = strrchr( p, ':');
if ( q == NULL || *(q+1) == '\0' ) {
message(LOG|CONSOLE,"Bad inittab entry: %s\n", lineAsRead);
continue;
} else {
*q='\0';
++q;
}
/* Now peal off the action field */
r = strrchr( p, ':');
if ( r == NULL || *(r+1) == '\0') {
message(LOG|CONSOLE,"Bad inittab entry: %s\n", lineAsRead);
continue;
} else {
++r;
}
/* Ok, now process it */
a = actions;
while (a->name != 0) {
if (strcmp(a->name, r) == 0) {
if (*s != '\0') {
struct stat statBuf;
strcpy(tmpConsole, "/dev/");
strncat(tmpConsole, s, 200);
if (stat(tmpConsole, &statBuf) != 0) {
message(LOG|CONSOLE, "device '%s' does not exist. Did you read the directions?\n", tmpConsole);
break;
}
s = tmpConsole;
}
new_initAction( a->action, q, s);
foundIt=TRUE;
}
a++;
}
if (foundIt==TRUE)
continue;
else {
/* Choke on an unknown action */
message(LOG|CONSOLE, "Bad inittab entry: %s\n", lineAsRead);
}
}
return;
#endif
}
extern int init_main(int argc, char **argv)
{
int run_rc = TRUE;
int wait_for_enter = TRUE;
pid_t pid1 = 0;
pid_t pid2 = 0;
struct stat statbuf;
const char* const init_commands[] = { INITSCRIPT, INITSCRIPT, 0};
const char* const shell_commands[] = { SHELL, "-" SHELL, 0};
const char* const* tty0_commands = shell_commands;
const char* const* tty1_commands = shell_commands;
#ifdef DEBUG_INIT
char *hello_msg_format =
"init(%d) started: BusyBox v%s (%s) multi-call binary\r\n";
#else
char *hello_msg_format =
"init started: BusyBox v%s (%s) multi-call binary\r\n";
#endif
initAction *a;
pid_t wpid;
int status;
/* Check if we are supposed to be in single user mode */
if ( argc > 1 && (!strcmp(argv[1], "single") ||
!strcmp(argv[1], "-s") || !strcmp(argv[1], "1"))) {
run_rc = FALSE;
#ifndef DEBUG_INIT
/* Expect to be PID 1 iff we are run as init (not linuxrc) */
if (getpid() != 1 && strstr(argv[0], "init")!=NULL ) {
usage( "init\n\nInit is the parent of all processes.\n\n"
"This version of init is designed to be run only by the kernel\n");
}
/* Fix up argv[0] to be certain we claim to be init */
strncpy(argv[0], "init", strlen(argv[0]));
/* Set up sig handlers -- be sure to
* clear all of these in run() */
signal(SIGUSR1, halt_signal);
@@ -418,7 +679,6 @@ extern int init_main(int argc, char **argv)
/* Turn off rebooting via CTL-ALT-DEL -- we get a
* SIGINT on CAD so we can shut things down gracefully... */
#ifndef DEBUG_INIT
reboot(RB_DISABLE_CAD);
#endif
@@ -433,68 +693,115 @@ extern int init_main(int argc, char **argv)
setsid();
/* Make sure PATH is set to something sane */
putenv(PATH_DEFAULT);
putenv(_PATH_STDPATH);
/* Hello world */
#ifndef DEBUG_INIT
message(CONSOLE|LOG, hello_msg_format, BB_VER, BB_BT);
message(LOG|CONSOLE,
"init started: BusyBox v%s (%s) multi-call binary\r\n",
BB_VER, BB_BT);
#else
message(CONSOLE|LOG, hello_msg_format, getpid(), BB_VER, BB_BT);
message(LOG|CONSOLE,
"init(%d) started: BusyBox v%s (%s) multi-call binary\r\n",
getpid(), BB_VER, BB_BT);
#endif
/* Mount /proc */
if (mount ("proc", "/proc", "proc", 0, 0) == 0)
message(CONSOLE|LOG, "Mounting /proc: done.\n");
else
message(CONSOLE|LOG, "Mounting /proc: failed!\n");
if (mount ("proc", "/proc", "proc", 0, 0) == 0) {
message(LOG|CONSOLE, "Mounting /proc: done.\n");
kernelVersion = get_kernel_revision();
} else
message(LOG|CONSOLE, "Mounting /proc: failed!\n");
/* Make sure there is enough memory to do something useful. */
check_memory();
/* Check if we are supposed to be in single user mode */
if ( argc > 1 && (!strcmp(argv[1], "single") ||
!strcmp(argv[1], "-s") || !strcmp(argv[1], "1")))
{
/* Ask first then start a shell on tty2 */
if (secondConsole != NULL)
new_initAction( ASKFIRST, SHELL, secondConsole);
/* Ask first then start a shell on tty1 */
new_initAction( ASKFIRST, SHELL, console);
} else {
/* Not in single user mode -- see what inittab says */
/* Make sure an init script exists before trying to run it */
if (run_rc == TRUE && stat(INITSCRIPT, &statbuf)==0) {
wait_for_enter = FALSE;
tty0_commands = init_commands;
/* NOTE that if BB_FEATURE_USE_INITTAB is NOT defined,
* then parse_inittab() simply adds in some default
* actions(i.e runs INIT_SCRIPT and then starts a pair
* of "askfirst" shells */
parse_inittab();
}
/* Now run everything that needs to be run */
/* Ok, now launch the rc script and/or prepare to
* start up some VTs if somebody hits enter...
*/
for (;;) {
pid_t wpid;
int status;
/* First run the sysinit command */
for( a=initActionList ; a; a=a->nextPtr) {
if (a->action == SYSINIT) {
waitfor(a->process, a->console, FALSE);
/* Now remove the "sysinit" entry from the list */
delete_initAction( a);
}
}
/* Next run anything that wants to block */
for( a=initActionList ; a; a=a->nextPtr) {
if (a->action == WAIT) {
waitfor(a->process, a->console, FALSE);
/* Now remove the "wait" entry from the list */
delete_initAction( a);
}
}
/* Next run anything to be run only once */
for( a=initActionList ; a; a=a->nextPtr) {
if (a->action == ONCE) {
run(a->process, a->console, FALSE);
/* Now remove the "once" entry from the list */
delete_initAction( a);
}
}
/* If there is nothing else to do, stop */
if (initActionList == NULL) {
message(LOG|CONSOLE, "No more tasks for init -- sleeping forever.\n");
while (1) sleep(1);
}
if (pid1 == 0 && tty0_commands) {
pid1 = run(tty0_commands, console, wait_for_enter);
}
if (pid2 == 0 && tty1_commands) {
pid2 = run(tty1_commands, second_console, TRUE);
/* Now run the looping stuff for the rest of forever */
while (1) {
for( a=initActionList ; a; a=a->nextPtr) {
/* Only run stuff with pid==0. If they have
* a pid, that means they are still running */
if (a->pid == 0) {
switch(a->action) {
case RESPAWN:
/* run the respawn stuff */
a->pid = run(a->process, a->console, FALSE);
break;
case ASKFIRST:
/* run the askfirst stuff */
a->pid = run(a->process, a->console, TRUE);
break;
/* silence the compiler's incessant whining */
default:
break;
}
}
}
/* Wait for a child process to exit */
wpid = wait(&status);
if (wpid > 0 ) {
message(LOG, "pid %d exited, status=%x.\n", wpid, status);
}
/* Don't respawn init script if it exits */
if (wpid == pid1) {
if (run_rc == FALSE) {
pid1 = 0;
}
#if 0
/* Turn this on to start a shell on the console if the init script exits.... */
else {
run_rc=FALSE;
wait_for_enter=TRUE;
tty0_commands=shell_commands;
/* Find out who died and clean up their corpse */
for( a=initActionList ; a; a=a->nextPtr) {
if (a->pid==wpid) {
a->pid=0;
message(LOG, "Process '%s' (pid %d) exited. Scheduling it for restart.\n",
a->process, wpid);
}
}
#endif
}
if (wpid == pid2) {
pid2 = 0;
}
sleep(1);
}
}
+31
View File
@@ -0,0 +1,31 @@
/*
* Mini poweroff implementation for busybox
*
*
* Copyright (C) 1995, 1996 by Bruce Perens <bruce@pixar.com>.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <signal.h>
extern int
poweroff_main(int argc, char ** argv)
{
/* don't assume init's pid == 1 */
exit( kill(findInitPid(), SIGUSR2));
}
+2 -1
View File
@@ -26,5 +26,6 @@
extern int
reboot_main(int argc, char ** argv)
{
exit( kill(1, SIGUSR2));
/* don't assume init's pid == 1 */
exit( kill(findInitPid(), SIGINT));
}
+206
View File
@@ -0,0 +1,206 @@
/*
* Mini insmod implementation for busybox
*
* Copyright (C) 1999 by Lineo, inc.
* Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/syscall.h>
#include <linux/module.h>
#define _PATH_MODULES "/lib/modules"
#warning "Danger Will Robinson, Danger!!!"
#warning " "
#warning "insmod is still under construction. Don't use it."
#warning " "
#warning " You have been warned!"
#warning " "
/* Some firendly syscalls to cheer everyone's day... */
_syscall2(int, init_module, const char *, name,
const struct module *, info)
#ifndef BB_RMMOD
_syscall1(int, delete_module, const char *, name)
#else
extern int delete_module(const char *);
#endif
#if defined(__i386__) || defined(__m68k__) || defined(__arm__)
/* Jump through hoops to fixup error return codes */
#define __NR__create_module __NR_create_module
static inline _syscall2(long, _create_module, const char *, name, size_t, size)
unsigned long create_module(const char *name, size_t size)
{
long ret = _create_module(name, size);
if (ret == -1 && errno > 125) {
ret = -errno;
errno = 0;
}
return ret;
}
#else
_syscall2(unsigned long, create_module, const char *, name, size_t, size)
#endif
static char m_filename[PATH_MAX] = "\0";
static char m_fullName[PATH_MAX] ="\0";
static const char insmod_usage[] =
"insmod [OPTION]... MODULE [symbol=value]...\n\n"
"Loads the specified kernel modules into the kernel.\n\n"
"Options:\n"
"\t-f\tForce module to load into the wrong kernel version.\n"
"\t-k\tMake module autoclean-able.\n";
static int findNamedModule(const char *fileName, struct stat* statbuf)
{
if (m_fullName[0]=='\0')
return( FALSE);
else {
char* tmp = strrchr( fileName, '/');
if (tmp == NULL)
tmp = (char*)fileName;
else
tmp++;
if (check_wildcard_match(tmp, m_fullName) == TRUE) {
/* Stop searching if we find a match */
memcpy(m_filename, fileName, strlen(fileName));
return( FALSE);
}
}
return( TRUE);
}
extern int insmod_main(int argc, char **argv)
{
int len;
char *tmp;
char m_name[PATH_MAX] ="\0";
FILE *fp;
if (argc<=1) {
usage( insmod_usage);
}
/* Parse any options */
while (--argc > 0 && **(++argv) == '-') {
while (*(++(*argv))) {
switch (**argv) {
case 'f':
break;
case 'k':
break;
default:
usage(insmod_usage);
}
}
}
if (argc <= 0 )
usage(insmod_usage);
/* Grab the module name */
if ((tmp = strrchr(*argv, '/')) != NULL)
tmp++;
else
tmp = *argv;
len = strlen(tmp);
if (len > 2 && tmp[len - 2] == '.' && tmp[len - 1] == 'o')
len -= 2;
memcpy(m_name, tmp, len);
strcpy(m_fullName, m_name);
strcat(m_fullName, ".o");
/* Get a filedesc for the module */
if ((fp = fopen(*argv, "r")) == NULL) {
/* Hmpf. Could not open it. Search through _PATH_MODULES to find a module named m_name */
if (recursiveAction(_PATH_MODULES, TRUE, FALSE, FALSE,
findNamedModule, findNamedModule) == FALSE) {
if ( m_filename[0] == '\0' || ((fp = fopen(m_filename, "r")) == NULL)) {
perror("No module by that name found in " _PATH_MODULES "\n");
exit( FALSE);
}
}
} else
memcpy(m_filename, *argv, strlen(*argv));
fprintf(stderr, "m_filename='%s'\n", m_filename);
fprintf(stderr, "m_name='%s'\n", m_name);
/* TODO: do something roughtly like this... */
#if 0
if ((f = obj_load(fp)) == NULL) {
perror("Could not load the module\n");
exit( FALSE);
}
/* Let the module know about the kernel symbols. */
add_kernel_symbols(f);
if (!create_this_module(f, m_name)) {
perror("Could not create the module\n");
exit( FALSE);
}
if (!obj_check_undefineds(f, quiet)) {
perror("Undefined symbols in the module\n");
exit( FALSE);
}
obj_allocate_commons(f);
/* Perse the module's arguments */
while (argc-- >0 && *(argv++) != '\0') {
if (!process_module_arguments(f, argc - optind, argv + optind)) {
perror("Undefined symbols in the module\n");
exit( FALSE);
}
}
/* Find current size of the module */
m_size = obj_load_size(f);
errno = 0;
m_addr = create_module(m_name, m_size);
switch (errno) {
/* yada yada */
default:
perror("create_module: %m");
}
#endif
fclose( fp);
exit( TRUE);
}
Executable
+20
View File
@@ -0,0 +1,20 @@
#!/bin/sh
set -e
if [ "$1" == "" ]; then
echo "No installation directory, aborting."
exit 1;
fi
h=`sort busybox.links | uniq`
for i in $h ; do
echo " $1$i -> /bin/busybox"
mkdir -p $1/`echo $i | sed -e 's/\/[^\/]*$//' `
ln -fs /bin/busybox $1$i
done
rm -f $1/bin/busybox
install -m 755 busybox $1/bin/busybox
exit 0
+53 -16
View File
@@ -29,11 +29,10 @@
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <mntent.h>
/* Some useful definitions */
#define STDIN 0
#define STDOUT 1
#define FALSE ((int) 1)
#define TRUE ((int) 0)
@@ -55,66 +54,88 @@ struct Applet {
extern int busybox_main(int argc, char** argv);
extern int block_device_main(int argc, char** argv);
extern int cat_main(int argc, char** argv);
extern int more_main(int argc, char** argv);
extern int cp_main(int argc, char** argv);
extern int chmod_chown_chgrp_main(int argc, char** argv);
extern int chroot_main(int argc, char** argv);
extern int chvt_main(int argc, char** argv);
extern int clear_main(int argc, char** argv);
extern int date_main(int argc, char** argv);
extern int dd_main(int argc, char** argv);
extern int deallocvt_main(int argc, char** argv);
extern int df_main(int argc, char** argv);
extern int dmesg_main(int argc, char** argv);
extern int du_main(int argc, char** argv);
extern int dutmp_main(int argc, char** argv);
extern int false_main(int argc, char** argv);
extern int fbset_main(int argc, char** argv);
extern int fdisk_main(int argc, char** argv);
extern int fdflush_main(int argc, char **argv);
extern int fsck_minix_main(int argc, char **argv);
extern int mkfs_minix_main(int argc, char **argv);
extern int find_main(int argc, char** argv);
extern int free_main(int argc, char** argv);
extern int grep_main(int argc, char** argv);
extern int gunzip_main (int argc, char** argv);
extern int gzip_main(int argc, char** argv);
extern int halt_main(int argc, char** argv);
extern int head_main(int argc, char** argv);
extern int hostid_main(int argc, char** argv);
extern int hostname_main(int argc, char** argv);
extern int init_main(int argc, char** argv);
extern int insmod_main(int argc, char** argv);
extern int kill_main(int argc, char** argv);
extern int length_main(int argc, char** argv);
extern int ln_main(int argc, char** argv);
extern int loadacm_main(int argc, char** argv);
extern int loadfont_main(int argc, char** argv);
extern int loadkmap_main(int argc, char** argv);
extern int losetup_main(int argc, char** argv);
extern int logger_main(int argc, char **argv);
extern int logname_main(int argc, char **argv);
extern int ls_main(int argc, char** argv);
extern int chvt_main(int argc, char** argv);
extern int deallocvt_main(int argc, char** argv);
extern int lsmod_main(int argc, char** argv);
extern int makedevs_main(int argc, char** argv);
extern int math_main(int argc, char** argv);
extern int mkdir_main(int argc, char** argv);
extern int mkfifo_main(int argc, char **argv);
extern int mkfs_minix_main(int argc, char **argv);
extern int mknod_main(int argc, char** argv);
extern int mkswap_main(int argc, char** argv);
extern int mnc_main(int argc, char** argv);
extern int more_main(int argc, char** argv);
extern int mount_main(int argc, char** argv);
extern int mt_main(int argc, char** argv);
extern int mv_main(int argc, char** argv);
extern int ping_main(int argc, char **argv);
extern int poweroff_main(int argc, char **argv);
extern int printf_main(int argc, char** argv);
extern int ps_main(int argc, char** argv);
extern int pwd_main(int argc, char** argv);
extern int reboot_main(int argc, char** argv);
extern int rmdir_main(int argc, char **argv);
extern int rm_main(int argc, char** argv);
extern int scan_partitions_main(int argc, char** argv);
extern int sh_main(int argc, char** argv);
extern int sfdisk_main(int argc, char** argv);
extern int rmdir_main(int argc, char **argv);
extern int rmmod_main(int argc, char** argv);
extern int sed_main(int argc, char** argv);
extern int sfdisk_main(int argc, char** argv);
extern int sleep_main(int argc, char** argv);
extern int sort_main(int argc, char** argv);
extern int swap_on_off_main(int argc, char** argv);
extern int sync_main(int argc, char** argv);
extern int syslogd_main(int argc, char **argv);
extern int tail_main(int argc, char** argv);
extern int tar_main(int argc, char** argv);
extern int tee_main(int argc, char** argv);
extern int touch_main(int argc, char** argv);
extern int tput_main(int argc, char** argv);
extern int true_main(int argc, char** argv);
extern int tput_main(int argc, char** argv);
extern int tryopen_main(int argc, char** argv);
extern int tty_main(int argc, char** argv);
extern int umount_main(int argc, char** argv);
extern int update_main(int argc, char** argv);
extern int uname_main(int argc, char** argv);
extern int zcat_main(int argc, char** argv);
extern int gzip_main(int argc, char** argv);
extern int uniq_main(int argc, char** argv);
extern int update_main(int argc, char** argv);
extern int wc_main(int argc, char** argv);
extern int whoami_main(int argc, char** argv);
extern int yes_main(int argc, char** argv);
const char *modeString(int mode);
@@ -137,7 +158,7 @@ const char* timeString(time_t timeVal);
extern void createPath (const char *name, int mode);
extern int parse_mode( const char* s, mode_t* theMode);
extern volatile void usage(const char *usage);
extern void usage(const char *usage) __attribute__ ((noreturn));
extern uid_t my_getpwnam(char *name);
extern gid_t my_getgrnam(char *name);
@@ -145,11 +166,22 @@ extern void my_getpwuid(char* name, uid_t uid);
extern void my_getgrgid(char* group, gid_t gid);
extern int get_kernel_revision();
extern int get_console_fd(char* tty_name);
extern struct mntent *findMountPoint(const char *name, const char *table);
extern void write_mtab(char* blockDevice, char* directory,
char* filesystemType, long flags, char* string_flags);
extern void erase_mtab(const char * name);
extern int check_wildcard_match(const char* text, const char* pattern);
extern long getNum (const char *cp);
extern pid_t findInitPid();
#if (__GLIBC__ < 2) && defined BB_SYSLOGD
extern int vdprintf(int d, const char *format, va_list ap);
#endif
#if defined BB_NFSMOUNT
int nfsmount(const char *spec, const char *node, unsigned long *flags,
char **extra_opts, char **mount_opts, int running_bg);
#endif
#if defined (BB_FSCK_MINIX) || defined (BB_MKFS_MINIX)
@@ -175,6 +207,11 @@ static inline int clrbit(char * addr,unsigned int nr)
#endif /* inline bitops junk */
#ifndef RB_POWER_OFF
/* Stop system and switch power off if possable. */
#define RB_POWER_OFF 0x4321fedc
#endif
#endif /* _INTERNAL_H_ */
+85 -28
View File
@@ -26,8 +26,14 @@
#include <unistd.h>
#include <signal.h>
#include <ctype.h>
#include <sys/stat.h>
#include <unistd.h>
static const char* kill_usage = "kill [-signal] process-id [process-id ...]\n\n"
"Send a signal (default is SIGTERM) to the specified process(es).\n\n"
"Options:\n"
"\t-l\tList all signal names and numbers.\n\n";
const char kill_usage[] = "kill [-signal] process-id [process-id ...]\n";
struct signal_name {
const char *name;
@@ -114,42 +120,93 @@ const struct signal_name signames[] = {
extern int kill_main (int argc, char **argv)
{
int sig = SIGTERM;
argc--;
argv++;
/* Parse any options */
if (argc < 1)
usage(kill_usage);
if ( argc < 2 )
usage (kill_usage);
while (argc > 0 && **argv == '-') {
while (*++(*argv)) {
switch (**argv) {
case 'l':
{
int col=0;
const struct signal_name *s = signames;
if ( **(argv+1) == '-' ) {
if (isdigit( *(*(++argv)+1) )) {
sig = atoi (*argv);
if (sig < 0 || sig >= NSIG)
goto end;
}
else {
const struct signal_name *s = signames;
while (s->name != 0) {
if (strcasecmp (s->name, *argv+1) == 0) {
sig = s->number;
break;
while (s->name != 0) {
col+=fprintf(stderr, "%2d) %-8s", s->number, (s++)->name);
if (col>60) {
fprintf(stderr, "\n");
col=0;
}
}
fprintf(stderr, "\n\n");
exit( TRUE);
}
break;
case '-':
usage(kill_usage);
default:
{
if (isdigit( **argv)) {
sig = atoi (*argv);
if (sig < 0 || sig >= NSIG)
goto end;
else {
argc--;
argv++;
goto do_it_now;
}
}
else {
const struct signal_name *s = signames;
while (s->name != 0) {
if (strcasecmp (s->name, *argv) == 0) {
sig = s->number;
argc--;
argv++;
goto do_it_now;
}
s++;
}
if (s->name == 0)
goto end;
}
}
s++;
}
if (s->name == 0)
goto end;
argc--;
argv++;
}
}
while (--argc > 1) {
int pid;
if (! isdigit( **(++argv))) {
fprintf(stderr, "bad PID: %s\n", *argv);
exit( FALSE);
}
pid = atoi (*argv);
if (kill (pid, sig) != 0) {
perror (*argv);
exit ( FALSE);
do_it_now:
while (--argc >= 0) {
int pid;
struct stat statbuf;
char pidpath[20]="/proc/";
if (! isdigit( **argv)) {
fprintf(stderr, "bad PID: %s\n", *argv);
exit( FALSE);
}
pid = atoi (*argv);
snprintf(pidpath, 20, "/proc/%s/stat", *argv);
if (stat( pidpath, &statbuf)!=0) {
fprintf(stderr, "kill: (%d) - No such pid\n", pid);
exit( FALSE);
}
fprintf(stderr, "sig = %d\n", sig);
if (kill (pid, sig) != 0) {
perror (*argv);
exit ( FALSE);
}
argv++;
}
exit ( TRUE);
end:
fprintf(stderr, "bad signal name: %s\n", *argv);
+14 -19
View File
@@ -27,23 +27,21 @@
#include <errno.h>
static const char ln_usage[] = "ln [-s] [-f] original-name additional-name\n"
"\n"
"\tAdd a new name that refers to the same file as \"original-name\"\n"
"\n"
"\t-s:\tUse a \"symbolic\" link, instead of a \"hard\" link.\n"
"\t-f:\tRemove existing destination files.\n";
static const char ln_usage[] = "ln [OPTION] TARGET... LINK_NAME|DIRECTORY\n\n"
"Create a link named LINK_NAME or DIRECTORY to the specified TARGET\n\n"
"Options:\n"
"\t-s\tmake symbolic links instead of hard links\n"
"\t-f\tremove existing destination files\n";
static int symlinkFlag = FALSE;
static int removeoldFlag = FALSE;
static const char *destName;
extern int ln_main(int argc, char **argv)
{
int status;
char newdestName[NAME_MAX];
static char* linkName;
if (argc < 3) {
usage (ln_usage);
@@ -69,30 +67,27 @@ extern int ln_main(int argc, char **argv)
}
destName = argv[argc - 1];
linkName = argv[argc - 1];
if ((argc > 3) && !(isDirectory(destName))) {
fprintf(stderr, "%s: not a directory\n", destName);
if ((argc > 3) && !(isDirectory(linkName))) {
fprintf(stderr, "%s: not a directory\n", linkName);
exit (FALSE);
}
while (argc-- >= 2) {
strcpy(newdestName, destName);
strcat(newdestName, (*argv)+(strlen(*(++argv))));
if (removeoldFlag==TRUE ) {
status = ( unlink(newdestName) && errno != ENOENT );
status = ( unlink(linkName) && errno != ENOENT );
if ( status != 0 ) {
perror(newdestName);
perror(linkName);
exit( FALSE);
}
}
if ( symlinkFlag==TRUE)
status = symlink(*argv, newdestName);
status = symlink(*argv, linkName);
else
status = link(*argv, newdestName);
status = link(*argv, linkName);
if ( status != 0 ) {
perror(newdestName);
perror(linkName);
exit( FALSE);
}
}
+441
View File
@@ -0,0 +1,441 @@
/*
* Derived from
* mapscrn.c - version 0.92
*
* Was taken from console-tools and adapted by
* Peter Novodvorsky <petya@logic.ru>
*/
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <errno.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/kd.h>
typedef unsigned short unicode;
static long int ctoi(unsigned char *s, int *is_unicode);
int old_screen_map_read_ascii(FILE *fp, unsigned char buf[]);
int uni_screen_map_read_ascii(FILE *fp, unicode buf[], int* is_unicode);
unicode utf8_to_ucs2 (char* buf);
int screen_map_load(int fd, FILE *fp);
int loadacm_main(int argc, char **argv)
{
int fd;
fd = open("/dev/tty", O_RDWR);
if (fd < 0) {
fprintf(stderr, "Error opening /dev/tty1: %s\n", strerror(errno));
return 1;
}
if (screen_map_load(fd, stdin))
{
fprintf(stderr, "Error loading acm: %s\n", strerror(errno));
return 1;
}
write(fd, "\033(K", 3);
return 0;
}
int screen_map_load(int fd, FILE *fp)
{
struct stat stbuf;
unicode wbuf[E_TABSZ];
unsigned char buf[E_TABSZ];
int parse_failed = 0;
int is_unicode;
if (fstat(fp->_fileno, &stbuf))
perror("Cannot stat map file"), exit(1);
/* first try a UTF screen-map: either ASCII (no restriction) or binary (regular file) */
if (!(parse_failed = (-1 == uni_screen_map_read_ascii(fp,wbuf,&is_unicode))) ||
(S_ISREG(stbuf.st_mode) &&
(stbuf.st_size == (sizeof(unicode) * E_TABSZ)))) /* test for binary UTF map by size */
{
if (parse_failed)
{
if (-1 == fseek (fp, 0, SEEK_SET))
{
if (errno == ESPIPE)
fprintf (stderr, "16bit screen-map MUST be a regular file.\n"), exit (1);
else
perror ("fseek failed reading binary 16bit screen-map"), exit (1);
}
if (fread(wbuf, sizeof(unicode) * E_TABSZ, 1, fp) != 1)
perror("Cannot read [new] map from file"), exit(1);
#if 0
else
fprintf(stderr, "Input screen-map is binary.\n");
#endif
}
/* if it was effectively a 16-bit ASCII, OK, else try to read as 8-bit map */
/* same if it was binary, ie. if parse_failed */
if (parse_failed || is_unicode)
{
if (ioctl(fd,PIO_UNISCRNMAP,wbuf))
perror("PIO_UNISCRNMAP ioctl"), exit(1);
else
return 0;
}
}
/* rewind... */
if (-1 == fseek (fp, 0, SEEK_SET))
{
if (errno == ESPIPE)
fprintf (stderr, "Assuming 8bit screen-map - MUST be a regular file.\n"), exit (1);
else
perror ("fseek failed assuming 8bit screen-map"), exit (1);
}
/* ... and try an old 8-bit screen-map */
if (!(parse_failed = (-1 == old_screen_map_read_ascii(fp,buf))) ||
(S_ISREG(stbuf.st_mode) &&
(stbuf.st_size == E_TABSZ))) /* test for binary old 8-bit map by size */
{
if (parse_failed)
{
if (-1 == fseek (fp, 0, SEEK_SET))
{
if (errno == ESPIPE)
/* should not - it succedeed above */
fprintf (stderr, "fseek() returned ESPIPE !\n"), exit (1);
else
perror ("fseek for binary 8bit screen-map"), exit (1);
}
if (fread(buf,E_TABSZ,1,fp) != 1)
perror("Cannot read [old] map from file"), exit(1);
#if 0
else
fprintf(stderr, "Input screen-map is binary.\n");
#endif
}
if (ioctl(fd,PIO_SCRNMAP,buf))
perror("PIO_SCRNMAP ioctl"), exit(1);
else
return 0;
}
else
{
fprintf(stderr, "Error parsing symbolic map\n");
exit(1);
}
}
/*
* - reads `fp' as a 16-bit ASCII SFM file.
* - returns -1 on error.
* - returns it in `unicode' in an E_TABSZ-elements array.
* - sets `*is_unicode' flagiff there were any non-8-bit
* (ie. real 16-bit) mapping.
*
* FIXME: ignores everything after second word
*/
int uni_screen_map_read_ascii(FILE *fp, unicode buf[], int *is_unicode)
{
char buffer[256]; /* line buffer reading file */
char *p, *q; /* 1st + 2nd words in line */
int in, on; /* the same, as numbers */
int tmp_is_unicode; /* tmp for is_unicode calculation */
int i; /* loop index - result holder */
int ret_code = 0; /* return code */
sigset_t sigset, old_sigset;
assert (is_unicode);
*is_unicode = 0;
/* first 128 codes defaults to ASCII */
for (i=0; i<128; i++) buf[i] = i;
/* remaining defaults to replacement char (usually E_TABSZ = 256) */
for ( ; i<E_TABSZ; i++) buf[i] = 0xfffd;
/* block SIGCHLD */
sigemptyset (&sigset);
sigaddset (&sigset, SIGCHLD);
sigprocmask (SIG_BLOCK, &sigset, &old_sigset);
do
{
if (NULL == fgets(buffer, sizeof(buffer),fp))
{
if (feof (fp))
break;
else
{
perror ("uni_screen_map_read_ascii() can't read line");
exit (2);
}
}
/* get "charset-relative charcode", stripping leading spaces */
p = strtok(buffer," \t\n");
/* skip empty lines and comments */
if (!p || *p == '#')
continue;
/* get unicode mapping */
q = strtok(NULL," \t\n");
if (q)
{
in = ctoi(p, NULL);
if (in < 0 || in > 255)
{
ret_code = -1;
break;
}
on = ctoi(q, &tmp_is_unicode);
if (in < 0 && on > 65535)
{
ret_code = -1;
break;
}
*is_unicode |= tmp_is_unicode;
buf[in] = on;
}
else
{
ret_code = -1;
break;
}
}
while (1); /* terminated by break on feof() */
/* restore sig mask */
sigprocmask (SIG_SETMASK, &old_sigset, NULL);
return ret_code;
}
int old_screen_map_read_ascii(FILE *fp, unsigned char buf[])
{
char buffer[256];
int in, on;
char *p, *q;
for (in=0; in<256; in++) buf[in]=in;
while (fgets(buffer,sizeof(buffer)-1,fp))
{
p = strtok(buffer," \t\n");
if (!p || *p == '#')
continue;
q = strtok(NULL," \t\n#");
if (q)
{
in = ctoi(p, NULL);
if (in < 0 || in > 255) return -1;
on = ctoi(q, NULL);
if (in < 0 && on > 255) return -1;
buf[in] = on;
}
else return -1;
}
return(0);
}
/*
* - converts a string into an int.
* - supports dec and hex bytes, hex UCS2, single-quoted byte and UTF8 chars.
* - returns the converted value
* - if `is_unicode != NULL', use it to tell whether it was unicode
*
* CAVEAT: will report valid UTF mappings using only 1 byte as 8-bit ones.
*/
long int ctoi(unsigned char *s, int *is_unicode)
{
int i;
size_t ls;
ls = strlen(s);
if (is_unicode) *is_unicode = 0;
/* hex-specified UCS2 */
if ((strncmp(s,"U+",2) == 0) &&
(strspn(s+2,"0123456789abcdefABCDEF") == ls-2))
{
sscanf(s+2,"%x",&i);
if (is_unicode) *is_unicode = 1;
}
/* hex-specified byte */
else if ((ls <= 4) && (strncmp(s,"0x",2) == 0) &&
(strspn(s+2,"0123456789abcdefABCDEF") == ls-2))
sscanf(s+2,"%x",&i);
/* oct-specified number (byte) */
else if ((*s == '0') &&
(strspn(s,"01234567") == ls))
sscanf(s,"%o",&i);
/* dec-specified number (byte) */
else if (strspn(s,"0123456789") == ls)
sscanf(s,"%d",&i);
/* single-byte quoted char */
else if ((strlen(s) == 3) && (s[0] == '\'') && (s[2] == '\''))
i=s[1];
/* multi-byte UTF8 quoted char */
else if ((s[0] == '\'') && (s[ls-1] == '\''))
{
s[ls-1] = 0; /* ensure we'll not "parse UTF too far" */
i = utf8_to_ucs2(s+1);
if (is_unicode) *is_unicode = 1;
}
else
return(-1);
return(i);
}
void saveoldmap(int fd, char *omfil)
{
FILE *fp;
char buf[E_TABSZ];
#ifdef GIO_UNISCRNMAP
unicode xbuf[E_TABSZ];
int is_old_map = 0;
if (ioctl(fd,GIO_UNISCRNMAP,xbuf))
{
perror("GIO_UNISCRNMAP ioctl error");
#endif
if (ioctl(fd,GIO_SCRNMAP,buf))
{
perror("GIO_SCRNMAP ioctl error");
exit(1);
}
else
is_old_map = 1;
#ifdef GIO_UNISCRNMAP
}
#endif
if ((fp = fopen(omfil, "w")) == NULL)
{
perror(omfil);
exit(1);
}
#ifdef GIO_UNISCRNMAP
if (is_old_map)
{
#endif
if (fwrite(buf,E_TABSZ,1,fp) != 1)
{
perror("Error writing map to file");
exit(1);
}
#ifdef GIO_UNISCRNMAP
}
else
if (fwrite(xbuf, sizeof(unicode) * E_TABSZ,1,fp) != 1)
{
perror("Error writing map to file");
exit(1);
}
#endif
fclose(fp);
}
unicode utf8_to_ucs2 (char* buf)
{
int utf_count = 0;
long utf_char;
unicode tc;
unsigned char c;
do
{
c = *buf;
buf++;
/* if byte should be part of multi-byte sequence */
if(c & 0x80)
{
/* if we have already started to parse a UTF8 sequence */
if (utf_count > 0 && (c & 0xc0) == 0x80)
{
utf_char = (utf_char << 6) | (c & 0x3f);
utf_count--;
if (utf_count == 0)
tc = utf_char;
else
continue;
}
else /* Possibly 1st char of a UTF8 sequence */
{
if ((c & 0xe0) == 0xc0)
{
utf_count = 1;
utf_char = (c & 0x1f);
}
else if ((c & 0xf0) == 0xe0)
{
utf_count = 2;
utf_char = (c & 0x0f);
}
else if ((c & 0xf8) == 0xf0)
{
utf_count = 3;
utf_char = (c & 0x07);
}
else if ((c & 0xfc) == 0xf8)
{
utf_count = 4;
utf_char = (c & 0x03);
}
else if ((c & 0xfe) == 0xfc)
{
utf_count = 5;
utf_char = (c & 0x01);
}
else
utf_count = 0;
continue;
}
}
else /* not part of multi-byte sequence - treat as ASCII
* this makes incomplete sequences to be ignored
*/
{
tc = c;
utf_count = 0;
}
}
while (utf_count);
return tc;
}
+194
View File
@@ -0,0 +1,194 @@
/*
* Mini logger implementation for busybox
*
* Copyright (C) 1999 by Lineo, inc.
* Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <unistd.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <ctype.h>
#include <netdb.h>
#if !defined BB_SYSLOGD
#define SYSLOG_NAMES
#include <sys/syslog.h>
#else
/* We have to do this since the header file defines static
* structues. Argh.... bad libc, bad, bad...
*/
#include <sys/syslog.h>
typedef struct _code {
char *c_name;
int c_val;
} CODE;
extern CODE prioritynames[];
extern CODE facilitynames[];
#endif
static const char logger_usage[] =
"logger [OPTION]... [MESSAGE]\n\n"
"Write MESSAGE to the system log. If MESSAGE is '-', log stdin.\n\n"
"Options:\n"
"\t-s\tLog to stderr as well as the system log.\n"
"\t-p\tEnter the message with the specified priority.\n"
"\t\tThis may be numerical or a ``facility.level'' pair.\n";
/* Decode a symbolic name to a numeric value
* this function is based on code
* Copyright (c) 1983, 1993
* The Regents of the University of California. All rights reserved.
*/
static int
decode(char* name, CODE* codetab)
{
CODE *c;
if (isdigit(*name))
return (atoi(name));
for (c = codetab; c->c_name; c++) {
if (!strcasecmp(name, c->c_name)) {
return (c->c_val);
}
}
return (-1);
}
/* Decode a symbolic name to a numeric value
* this function is based on code
* Copyright (c) 1983, 1993
* The Regents of the University of California. All rights reserved.
*/
static int
pencode(char* s)
{
char *save;
int lev, fac=LOG_USER;
for (save = s; *s && *s != '.'; ++s);
if (*s) {
*s = '\0';
fac = decode(save, facilitynames);
if (fac < 0) {
fprintf(stderr, "unknown facility name: %s\n", save);
exit( FALSE);
}
*s++ = '.';
}
else {
s = save;
}
lev = decode(s, prioritynames);
if (lev < 0) {
fprintf(stderr, "unknown priority name: %s\n", save);
exit( FALSE);
}
return ((lev & LOG_PRIMASK) | (fac & LOG_FACMASK));
}
extern int logger_main(int argc, char **argv)
{
struct sockaddr_un sunx;
int fd, pri = LOG_USER|LOG_NOTICE;
int fromStdinFlag=FALSE;
int toStdErrFlag=FALSE;
int stopLookingAtMeLikeThat=FALSE;
char *message, buf[1024], buf1[1024];
time_t now;
size_t addrLength;
/* Parse any options */
while (--argc > 0 && **(++argv) == '-') {
if (*((*argv)+1) == '\0') {
fromStdinFlag=TRUE;
}
stopLookingAtMeLikeThat=FALSE;
while (*(++(*argv)) && stopLookingAtMeLikeThat==FALSE) {
switch (**argv) {
case 's':
toStdErrFlag = TRUE;
break;
case 'p':
if (--argc == 0) {
usage(logger_usage);
}
pri = pencode(*(++argv));
stopLookingAtMeLikeThat=TRUE;
break;
default:
usage(logger_usage);
}
}
}
if (fromStdinFlag==TRUE) {
/* read from stdin */
int c, i=0;
while ((c = getc(stdin)) != EOF && i<sizeof(buf1)) {
buf1[i++]=c;
}
message=buf1;
} else {
if (argc>=1) {
message=*argv;
} else {
fprintf(stderr, "No message\n");
exit( FALSE);
}
}
memset(&sunx, 0, sizeof(sunx));
sunx.sun_family = AF_UNIX; /* Unix domain socket */
strncpy(sunx.sun_path, _PATH_LOG, sizeof(sunx.sun_path));
if ((fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0 ) {
perror("Couldn't obtain descriptor for socket " _PATH_LOG);
exit( FALSE);
}
addrLength = sizeof(sunx.sun_family) + strlen(sunx.sun_path);
if (connect(fd, (struct sockaddr *) &sunx, addrLength)) {
perror("Could not connect to socket " _PATH_LOG);
exit( FALSE);
}
time(&now);
snprintf (buf, sizeof(buf), "<%d>%.15s %s", pri, ctime(&now)+4, message);
if (toStdErrFlag==TRUE)
fprintf(stderr, "%s\n", buf);
write( fd, buf, strlen(buf)+1);
close(fd);
exit( TRUE);
}
+40
View File
@@ -0,0 +1,40 @@
/*
* Mini logname implementation for busybox
*
* Copyright (C) 2000 Edward Betts <edward@debian.org>.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
static const char logname_usage[] = "logname\n\n"
"Print the name of the current user.\n";
extern int logname_main(int argc, char **argv) {
char *cp;
if (argc > 1) usage (logname_usage);
cp = getlogin ();
if (cp) {
puts (cp);
exit (TRUE);
}
fprintf (stderr, "%s: no login name\n", argv[0]);
exit (FALSE);
}
+58 -87
View File
@@ -40,11 +40,6 @@
* 1. requires lstat (BSD) - how do you do it without?
*/
//#define FEATURE_USERNAME /* show username/groupnames (libc6 uses NSS) */
#define FEATURE_TIMESTAMPS /* show file timestamps */
#define FEATURE_AUTOWIDTH /* calculate terminal & column widths */
#define FEATURE_FILETYPECHAR /* enable -p and -F */
#define TERMINAL_WIDTH 80 /* use 79 if your terminal has linefold bug */
#define COLUMN_WIDTH 14 /* default if AUTOWIDTH not defined */
#define COLUMN_GAP 2 /* includes the file type char, if present */
@@ -64,17 +59,13 @@
#include <dirent.h>
#include <errno.h>
#include <stdio.h>
#ifdef FEATURE_USERNAME
#include <pwd.h>
#include <grp.h>
#endif
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
#include <time.h>
#endif
#define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
#define TYPECHAR(mode) ("0pcCd?bB-?l?s???" [TYPEINDEX(mode)])
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
#define APPCHAR(mode) ("\0|\0\0/\0\0\0\0\0@\0=\0\0\0" [TYPEINDEX(mode)])
#endif
@@ -83,27 +74,6 @@
#define MINOR(dev) ((dev)&0xff)
#endif
#define MODE1 "rwxrwxrwx"
#define MODE0 "---------"
#define SMODE1 "..s..s..t"
#define SMODE0 "..S..S..T"
/* The 9 mode bits to test */
static const mode_t MBIT[] = {
S_IRUSR, S_IWUSR, S_IXUSR,
S_IRGRP, S_IWGRP, S_IXGRP,
S_IROTH, S_IWOTH, S_IXOTH
};
/* The special bits. If set, display SMODE0/1 instead of MODE0/1 */
static const mode_t SBIT[] = {
0, 0, S_ISUID,
0, 0, S_ISGID,
0, 0, S_ISVTX
};
#define FMT_AUTO 0
#define FMT_LONG 1 /* one record per line, extended info */
#define FMT_SINGLE 2 /* one record per line */
@@ -128,14 +98,14 @@ static unsigned char display_fmt = FMT_AUTO;
static unsigned short opts = 0;
static unsigned short column = 0;
#ifdef FEATURE_AUTOWIDTH
#ifdef BB_FEATURE_AUTOWIDTH
static unsigned short terminal_width = 0, column_width = 0;
#else
#define terminal_width TERMINAL_WIDTH
#define column_width COLUMN_WIDTH
#endif
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
static unsigned char time_fmt = TIME_MOD;
#endif
@@ -188,7 +158,7 @@ static void tab(short col)
#undef nspaces
}
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
static char append_char(mode_t mode)
{
if (!(opts & DISP_FTYPE))
@@ -206,55 +176,55 @@ static char append_char(mode_t mode)
**
**/
static void list_single(const char *name, struct stat *info)
static void list_single(const char *name, struct stat *info, const char *fullname)
{
char scratch[PATH_MAX];
short len = strlen(name);
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
char append = append_char(info->st_mode);
#endif
if (display_fmt == FMT_LONG) {
mode_t mode = info->st_mode;
int i;
scratch[0] = TYPECHAR(mode);
for (i=0; i<9; i++)
if (mode & SBIT[i])
scratch[i+1] = (mode & MBIT[i])
? SMODE1[i]
: SMODE0[i];
else
scratch[i+1] = (mode & MBIT[i])
? MODE1[i]
: MODE0[i];
newline();
wr(scratch, 10);
wr(modeString(mode), 10);
column=10;
writenum((long)info->st_nlink,(short)4);
writenum((long)info->st_nlink,(short)5);
fputs(" ", stdout);
#ifdef FEATURE_USERNAME
#ifdef BB_FEATURE_LS_USERNAME
if (!(opts & DISP_NUMERIC)) {
struct passwd *pw = getpwuid(info->st_uid);
if (pw)
fputs(pw->pw_name, stdout);
else
writenum((long)info->st_uid,(short)0);
memset ( scratch, 0, sizeof (scratch));
my_getpwuid( scratch, info->st_uid);
if (*scratch) {
fputs(scratch, stdout);
if ( strlen( scratch) <= 8 )
wr(" ", 8-strlen( scratch));
}
else {
writenum((long) info->st_uid,(short)8);
fputs(" ", stdout);
}
} else
#endif
writenum((long)info->st_uid,(short)0);
tab(24);
#ifdef FEATURE_USERNAME
{
writenum((long) info->st_uid,(short)8);
fputs(" ", stdout);
}
#ifdef BB_FEATURE_LS_USERNAME
if (!(opts & DISP_NUMERIC)) {
struct group *gr = getgrgid(info->st_gid);
if (gr)
fputs(gr->gr_name, stdout);
else
writenum((long)info->st_gid,(short)0);
memset ( scratch, 0, sizeof (scratch));
my_getgrgid( scratch, info->st_gid);
if (*scratch) {
fputs(scratch, stdout);
if ( strlen( scratch) <= 8 )
wr(" ", 8-strlen( scratch));
}
else
writenum((long) info->st_gid,(short)8);
} else
#endif
writenum((long)info->st_gid,(short)0);
tab(33);
writenum((long) info->st_gid,(short)8);
//tab(26);
if (S_ISBLK(mode) || S_ISCHR(mode)) {
writenum((long)MAJOR(info->st_rdev),(short)3);
fputs(", ", stdout);
@@ -263,7 +233,8 @@ static void list_single(const char *name, struct stat *info)
else
writenum((long)info->st_size,(short)8);
fputs(" ", stdout);
#ifdef FEATURE_TIMESTAMPS
//tab(32);
#ifdef BB_FEATURE_LS_TIMESTAMPS
{
time_t cal;
char *string;
@@ -297,12 +268,12 @@ static void list_single(const char *name, struct stat *info)
wr(name, len);
if (S_ISLNK(mode)) {
wr(" -> ", 4);
len = readlink(name, scratch, sizeof scratch);
len = readlink(fullname, scratch, sizeof scratch);
if (len > 0) fwrite(scratch, 1, len, stdout);
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
/* show type of destination */
if (opts & DISP_FTYPE) {
if (!stat(name, info)) {
if (!stat(fullname, info)) {
append = append_char(info->st_mode);
if (append)
fputc(append, stdout);
@@ -310,7 +281,7 @@ static void list_single(const char *name, struct stat *info)
}
#endif
}
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
else if (append)
wr(&append, 1);
#endif
@@ -324,7 +295,7 @@ static void list_single(const char *name, struct stat *info)
newline();
else {
if (nexttab + column_width > terminal_width
#ifndef FEATURE_AUTOWIDTH
#ifndef BB_FEATURE_AUTOWIDTH
|| nexttab + len >= terminal_width
#endif
)
@@ -333,7 +304,7 @@ static void list_single(const char *name, struct stat *info)
tab(nexttab);
}
/* work out where next column starts */
#ifdef FEATURE_AUTOWIDTH
#ifdef BB_FEATURE_AUTOWIDTH
/* we know the calculated width is big enough */
nexttab = column + column_width + COLUMN_GAP;
#else
@@ -346,7 +317,7 @@ static void list_single(const char *name, struct stat *info)
/* now write the data */
wr(name, len);
column = column + len;
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
if (append)
wr(&append, 1), column++;
#endif
@@ -372,7 +343,7 @@ static int list_item(const char *name)
if (!S_ISDIR(info.st_mode) ||
(opts & DIR_NOLIST)) {
list_single(name, &info);
list_single(name, &info, name);
return 0;
}
@@ -387,7 +358,7 @@ static int list_item(const char *name)
dir = opendir(name);
if (!dir) goto listerr;
#ifdef FEATURE_AUTOWIDTH
#ifdef BB_FEATURE_AUTOWIDTH
column_width = 0;
while ((entry = readdir(dir)) != NULL) {
short w = strlen(entry->d_name);
@@ -424,7 +395,7 @@ static int list_item(const char *name)
strcpy(fnend, entry->d_name);
if (lstat(fullname, &info))
goto direrr; /* (shouldn't fail) */
list_single(entry->d_name, &info);
list_single(entry->d_name, &info, fullname);
}
closedir(dir);
return 0;
@@ -438,22 +409,22 @@ listerr:
}
static const char ls_usage[] = "ls [-1a"
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
"c"
#endif
"d"
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
"e"
#endif
"ln"
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
"p"
#endif
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
"u"
#endif
"xAC"
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
"F"
#endif
#ifdef FEATURE_RECURSIVE
@@ -486,7 +457,7 @@ ls_main(int argc, char * * argv)
case '1': display_fmt = FMT_SINGLE; break;
case 'x': display_fmt = FMT_ROWS; break;
case 'C': display_fmt = FMT_COLUMNS; break;
#ifdef FEATURE_FILETYPECHAR
#ifdef BB_FEATURE_LS_FILETYPES
case 'p': opts |= DISP_FTYPE; break;
case 'F': opts |= DISP_FTYPE|DISP_EXEC; break;
#endif
@@ -497,7 +468,7 @@ ls_main(int argc, char * * argv)
#ifdef FEATURE_RECURSIVE
case 'R': opts |= DIR_RECURSE; break;
#endif
#ifdef FEATURE_TIMESTAMPS
#ifdef BB_FEATURE_LS_TIMESTAMPS
case 'u': time_fmt = TIME_ACCESS; break;
case 'c': time_fmt = TIME_CHANGE; break;
case 'e': opts |= DISP_FULLTIME; break;
@@ -510,10 +481,10 @@ ls_main(int argc, char * * argv)
/* choose a display format */
if (display_fmt == FMT_AUTO)
display_fmt = isatty(STDOUT_FILENO) ? FMT_COLUMNS : FMT_SINGLE;
display_fmt = isatty(fileno(stdout)) ? FMT_COLUMNS : FMT_SINGLE;
if (argi < argc - 1)
opts |= DISP_DIRNAME; /* 2 or more items? label directories */
#ifdef FEATURE_AUTOWIDTH
#ifdef BB_FEATURE_AUTOWIDTH
/* could add a -w option and/or TIOCGWINSZ call */
if (terminal_width < 1) terminal_width = TERMINAL_WIDTH;
+35
View File
@@ -0,0 +1,35 @@
/*
* Mini lsmod implementation for busybox
*
* Copyright (C) 1999 by Lineo, inc.
* Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
#if ! defined BB_FEATURE_USE_PROCFS
#error Sorry, I depend on the /proc filesystem right now.
#endif
extern int lsmod_main(int argc, char **argv)
{
char* cmd[] = { "cat", "/proc/modules", "\0" };
exit(cat_main( 3, cmd));
}
+1 -1
View File
@@ -19,7 +19,7 @@ static const char dutmp_usage[] = "dutmp\n"
"\tDump file or stdin utmp file format to stdout, pipe delimited.\n"
"\tdutmp /var/run/utmp\n";
static int dutmp_main (int argc, char **argv)
extern int dutmp_main (int argc, char **argv)
{
FILE *f = stdin;
+17 -11
View File
@@ -26,14 +26,15 @@
#include <errno.h>
#include <sys/param.h>
static const char mkdir_usage[] = "Usage: mkdir [OPTION] DIRECTORY...\n"
static const char mkdir_usage[] = "Usage: mkdir [OPTION] DIRECTORY...\n\n"
"Create the DIRECTORY(ies), if they do not already exist\n\n"
"-m\tset permission mode (as in chmod), not rwxrwxrwx - umask\n"
"-p\tno error if existing, make parent directories as needed\n";
"Options:\n"
"\t-m\tset permission mode (as in chmod), not rwxrwxrwx - umask\n"
"\t-p\tno error if existing, make parent directories as needed\n";
static int parentFlag = FALSE;
static mode_t mode = 777;
static mode_t mode = 0777;
extern int mkdir_main(int argc, char **argv)
@@ -79,16 +80,21 @@ extern int mkdir_main(int argc, char **argv)
while (argc > 0) {
int status;
struct stat statBuf;
status=stat(*argv, &statBuf);
if (status != -1 && status != ENOENT ) {
fprintf(stderr, "%s: File exists\n", *argv);
char buf[NAME_MAX];
strcpy (buf, *argv);
status=stat(buf, &statBuf);
if (parentFlag == FALSE && status != -1 && status != ENOENT ) {
fprintf(stderr, "%s: File exists\n", buf);
exit( FALSE);
}
if (parentFlag == TRUE)
createPath(*argv, mode);
if (parentFlag == TRUE) {
strcat( buf, "/");
createPath(buf, mode);
}
else {
if (mkdir (*argv, mode) != 0) {
perror(*argv);
if (mkdir (buf, mode) != 0 && parentFlag == FALSE) {
perror(buf);
exit( FALSE);
}
}
+61
View File
@@ -0,0 +1,61 @@
/*
* Mini mkfifo implementation for busybox
*
* Copyright (C) 1999 by Randolph Chung <tausq@debian.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "internal.h"
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
static const char mkfifo_usage[] = "mkfifo [OPTIONS] name\n\n"
"Create the named fifo\n\n"
"Options:\n"
"\t-m\tcreate the fifo with the specified mode; default = a=rw-umask\n";
extern int mkfifo_main(int argc, char **argv)
{
char *thisarg;
mode_t mode = 0666;
argc--;
argv++;
/* Parse any options */
while (argc > 1) {
if (**argv != '-') usage(mkfifo_usage);
thisarg = *argv; thisarg++;
switch (*thisarg) {
case 'm':
argc--; argv++;
parse_mode(*argv, &mode);
break;
default:
usage (mkfifo_usage);
}
argc--; argv++;
}
if (argc < 1) usage (mkfifo_usage);
if (mkfifo(*argv, mode) < 0) {
perror("mkfifo");
exit(255);
} else {
exit(TRUE);
}
}
+9 -4
View File
@@ -171,10 +171,15 @@ static volatile void die(char *str) {
static volatile void show_usage()
{
fprintf(stderr, "%s\n", program_name);
fprintf(stderr,
"Usage: %s [-c | -l filename] [-nXX] [-iXX] /dev/name [blocks]\n",
program_name);
fprintf(stderr, "BusyBox v%s (%s) multi-call binary -- GPL2\n\n", BB_VER, BB_BT);
fprintf(stderr, "Usage: %s [-c | -l filename] [-nXX] [-iXX] /dev/name [blocks]\n\n", program_name);
fprintf(stderr, "Make a MINIX filesystem.\n\n");
fprintf(stderr, "OPTIONS:\n");
fprintf(stderr, "\t-c\t\tCheck the device for bad blocks\n");
fprintf(stderr, "\t-n [14|30]\tSpecify the maximum length of filenames\n");
fprintf(stderr, "\t-i\t\tSpecify the number of inodes for the filesystem\n");
fprintf(stderr, "\t-l FILENAME\tRead the bad blocks list from FILENAME\n");
fprintf(stderr, "\t-v\t\tMake a Minix version 2 filesystem\n\n");
exit(16);
}
+6 -3
View File
@@ -27,9 +27,9 @@
#include <fcntl.h>
#include <unistd.h>
static const char mknod_usage[] = "mknod file b|c|u|p major minor\n"
"\tMake special files.\n"
"\n"
static const char mknod_usage[] = "mknod NAME TYPE MAJOR MINOR\n\n"
"Make block or character special files.\n\n"
"TYPEs include:\n"
"\tb:\tMake a block (buffered) device.\n"
"\tc or u:\tMake a character (un-buffered) device.\n"
"\tp:\tMake a named pipe. Major and minor are ignored for named pipes.\n";
@@ -40,6 +40,9 @@ mknod_main(int argc, char** argv)
mode_t mode = 0;
dev_t dev = 0;
if ( argc != 5 || **(argv+1) == '-' ) {
usage (mknod_usage);
}
switch(argv[2][0]) {
case 'c':
case 'u':
+5 -4
View File
@@ -47,11 +47,12 @@
/* we also get PAGE_SIZE via getpagesize() */
static const char mkswap_usage[] = "mkswap [-c] [-v0|-v1] device [block-count]\n"
static const char mkswap_usage[] = "mkswap [-c] [-v0|-v1] device [block-count]\n\n"
"Prepare a disk partition to be used as a swap partition.\n\n"
"\t-c\tCheck for read-ability.\n"
"\t-v0\tMake version 0 swap [max 128 Megs].\n"
"\t-v1\tMake version 1 swap [big!] (default for kernels > 2.1.117).\n"
"Options:\n"
"\t-c\t\tCheck for read-ability.\n"
"\t-v0\t\tMake version 0 swap [max 128 Megs].\n"
"\t-v1\t\tMake version 1 swap [big!] (default for kernels > 2.1.117).\n"
"\tblock-count\tNumber of block to use (default is entire partition).\n";
Loaded 100 of 155 files, more files were not shown because too many files have changed in this diff. Show more