Compare commits
461
Commits
1_8_2
...
1_10_stable
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e9f8b2f830 | ||
|
|
49b78fc1a8 | ||
|
|
a3087ca749 | ||
|
|
0abe9d96ee | ||
|
|
378481ed1e | ||
|
|
fc9fc1f929 | ||
|
|
74f8208f18 | ||
|
|
ffa5d76602 | ||
|
|
45911a60c3 | ||
|
|
31567c1c70 | ||
|
|
68d09697c9 | ||
|
|
4824ccae8e | ||
|
|
0dc490bda2 | ||
|
|
f90ab183d6 | ||
|
|
275b929e01 | ||
|
|
9e1f92d0bb | ||
|
|
9230582315 | ||
|
|
c52248e41c | ||
|
|
3c96d0258c | ||
|
|
0f3a580c4f | ||
|
|
027271e5a9 | ||
|
|
0a0180cdc5 | ||
|
|
104d544fd7 | ||
|
|
dd5702d696 | ||
|
|
a7d6c8bab9 | ||
|
|
cf7cf62204 | ||
|
|
0764a7f72d | ||
|
|
7a60133c6c | ||
|
|
403a5a298e | ||
|
|
71c9f015e9 | ||
|
|
dd9228b861 | ||
|
|
c0183e6e0d | ||
|
|
6aa7696e28 | ||
|
|
2a7a451391 | ||
|
|
d7e6af2dda | ||
|
|
78c5656530 | ||
|
|
e421b5ebf6 | ||
|
|
2724fa9d8a | ||
|
|
fb274df079 | ||
|
|
9c8c038981 | ||
|
|
d1277c6052 | ||
|
|
d0a071a528 | ||
|
|
b44c790e41 | ||
|
|
d25c33f186 | ||
|
|
c5b737231d | ||
|
|
592d4fe772 | ||
|
|
4866e905d7 | ||
|
|
4ee7cd4f6f | ||
|
|
aa9b1828b9 | ||
|
|
1d42665b6b | ||
|
|
62a90cdd74 | ||
|
|
d02db89244 | ||
|
|
85c247161b | ||
|
|
081eb71ebd | ||
|
|
68404f13d4 | ||
|
|
a55bd05f3c | ||
|
|
397de617f3 | ||
|
|
a4522c5a66 | ||
|
|
afc4113ed7 | ||
|
|
cdf62770af | ||
|
|
107fe7c081 | ||
|
|
aefed941c2 | ||
|
|
9f153f610f | ||
|
|
3f165fa5b3 | ||
|
|
8e2cfec1cd | ||
|
|
4cf1d08fc2 | ||
|
|
4e6d5117b8 | ||
|
|
4e6c8120a5 | ||
|
|
35e9c5d83a | ||
|
|
c51fc7bed6 | ||
|
|
b4a5087ee0 | ||
|
|
4917c11432 | ||
|
|
a43dba76ea | ||
|
|
444639cc21 | ||
|
|
c3fff877e1 | ||
|
|
4aafd5f4e3 | ||
|
|
d18f52bd18 | ||
|
|
fb29038b59 | ||
|
|
509697f00d | ||
|
|
da8ae75340 | ||
|
|
fe2188378c | ||
|
|
8a2e421f26 | ||
|
|
19fb67eee4 | ||
|
|
b29028e351 | ||
|
|
f39c7c0c86 | ||
|
|
cd174d1f31 | ||
|
|
32fd76c1d5 | ||
|
|
93e1a215af | ||
|
|
3444bd4fc2 | ||
|
|
51f421a55c | ||
|
|
1acb4ef87e | ||
|
|
574f2f4394 | ||
|
|
fe66a0eca1 | ||
|
|
c8f2f74ddd | ||
|
|
5014dada3f | ||
|
|
8195d20e36 | ||
|
|
17db1a9ac1 | ||
|
|
7be1030dcc | ||
|
|
be048f21e6 | ||
|
|
06aed4316e | ||
|
|
04bb2d2d06 | ||
|
|
d4f0b9476a | ||
|
|
d686482d05 | ||
|
|
6f1713f216 | ||
|
|
394eebed66 | ||
|
|
38b8831b32 | ||
|
|
f99afb5dff | ||
|
|
a2f47358eb | ||
|
|
6d8112cc24 | ||
|
|
8f8a420f12 | ||
|
|
b78d1c045f | ||
|
|
4f82bdb050 | ||
|
|
52feee9b1f | ||
|
|
28b29916cb | ||
|
|
400d8bb45e | ||
|
|
d553faf5a5 | ||
|
|
a7259b64e8 | ||
|
|
d2172c04e6 | ||
|
|
33196372be | ||
|
|
86620756d2 | ||
|
|
32b2a9fd6a | ||
|
|
68444b9f0c | ||
|
|
6aa74fcf5b | ||
|
|
838ffd5be2 | ||
|
|
2f518b078b | ||
|
|
081efd1232 | ||
|
|
a523e2efad | ||
|
|
84da0bf475 | ||
|
|
e376d454bb | ||
|
|
ae86a338b8 | ||
|
|
597906c436 | ||
|
|
e7b43cf59f | ||
|
|
c12d51e94e | ||
|
|
624188aec0 | ||
|
|
671ca33aa1 | ||
|
|
a58a637bed | ||
|
|
99a61842df | ||
|
|
8617454027 | ||
|
|
e93550866b | ||
|
|
53ce7f0d71 | ||
|
|
431a7c9c53 | ||
|
|
a37e7134f7 | ||
|
|
92657d484f | ||
|
|
e8419c90f1 | ||
|
|
5233cd3800 | ||
|
|
6f04391cec | ||
|
|
de7684a309 | ||
|
|
27dd495b98 | ||
|
|
b4133683a4 | ||
|
|
f732e96757 | ||
|
|
c9ca0a3274 | ||
|
|
56244736ec | ||
|
|
542963685c | ||
|
|
03b4c14bd4 | ||
|
|
b3b0753593 | ||
|
|
cb448fe01b | ||
|
|
ffae845cfd | ||
|
|
b1d8e7db0f | ||
|
|
25591c322c | ||
|
|
7fc294cdfe | ||
|
|
3718832a15 | ||
|
|
1e18f1bab3 | ||
|
|
284d0faed6 | ||
|
|
069e347863 | ||
|
|
cd5c61cd3b | ||
|
|
753f42ab8d | ||
|
|
0e6f661e23 | ||
|
|
977bc6a137 | ||
|
|
ea915363e7 | ||
|
|
6b160e490d | ||
|
|
be7d2a8ded | ||
|
|
25cd7fd702 | ||
|
|
1e47c429bf | ||
|
|
e00e5025ec | ||
|
|
39487e2d6a | ||
|
|
94e87bc83d | ||
|
|
28bf671d6d | ||
|
|
f1d93ec420 | ||
|
|
b2e578a1f2 | ||
|
|
773f6710c1 | ||
|
|
12c0622231 | ||
|
|
b5ee8db9b5 | ||
|
|
65eb550024 | ||
|
|
81887e2342 | ||
|
|
23ffb6a4a2 | ||
|
|
6dd03f04ea | ||
|
|
87cf2ee8ab | ||
|
|
d5fe880a57 | ||
|
|
9d96af2e83 | ||
|
|
3b92eaac53 | ||
|
|
75cddd8eb5 | ||
|
|
0a4624aece | ||
|
|
59bb4a4f50 | ||
|
|
7c5258b1c4 | ||
|
|
3d3d698594 | ||
|
|
fee2d0c256 | ||
|
|
7e497527ea | ||
|
|
e26b2783a5 | ||
|
|
648b44fd78 | ||
|
|
a5f2cd30c9 | ||
|
|
fc21305892 | ||
|
|
f536b99d26 | ||
|
|
a985d306a1 | ||
|
|
83177991c8 | ||
|
|
08126f665d | ||
|
|
459a5ad410 | ||
|
|
4ecfcdcced | ||
|
|
c04163a289 | ||
|
|
04e11c9209 | ||
|
|
9304d6ea92 | ||
|
|
991a1da148 | ||
|
|
0ef240d979 | ||
|
|
05743d7949 | ||
|
|
68e8e96d7f | ||
|
|
d56e3ccf96 | ||
|
|
937b10f35d | ||
|
|
761e1d1462 | ||
|
|
65581f3ed1 | ||
|
|
1e2a7e4ed1 | ||
|
|
6d52c1ee24 | ||
|
|
dc1c45795b | ||
|
|
97bd0e05cc | ||
|
|
7dbf1b4d9e | ||
|
|
afdad653ac | ||
|
|
534b8d0483 | ||
|
|
9412ec7555 | ||
|
|
22876c797c | ||
|
|
b386c1c614 | ||
|
|
d55fe3e595 | ||
|
|
e8ef7ec7de | ||
|
|
f3f33ebb0b | ||
|
|
f8157cafcb | ||
|
|
32d49bc70f | ||
|
|
c85bfcad52 | ||
|
|
5c3d2b334a | ||
|
|
95dc672326 | ||
|
|
30eb319103 | ||
|
|
6e602c4931 | ||
|
|
80667e30fb | ||
|
|
a2980c6249 | ||
|
|
5de754a395 | ||
|
|
7cff01ec2d | ||
|
|
0b2b5842a1 | ||
|
|
f0044c480c | ||
|
|
c348e0bc7b | ||
|
|
8c69afd992 | ||
|
|
c882f341ce | ||
|
|
8c638cbf09 | ||
|
|
c96d37050f | ||
|
|
36fc3cd8bc | ||
|
|
ddd42cb064 | ||
|
|
9772816570 | ||
|
|
73032ca04b | ||
|
|
847fa779af | ||
|
|
0effc2410b | ||
|
|
b5c60fc787 | ||
|
|
da42bd5bbe | ||
|
|
ef67c5758a | ||
|
|
c4e4be9414 | ||
|
|
f470196a41 | ||
|
|
61160dd0a1 | ||
|
|
b76b9a4328 | ||
|
|
893988182a | ||
|
|
ca9635b19d | ||
|
|
a5549c9617 | ||
|
|
680b86afbb | ||
|
|
1d290d1e24 | ||
|
|
9e58921e7e | ||
|
|
314820e595 | ||
|
|
8e8200a772 | ||
|
|
46ef46aefb | ||
|
|
46904bfbcc | ||
|
|
518d8dd979 | ||
|
|
52432f2b06 | ||
|
|
2b11fb483e | ||
|
|
c2f0de5eef | ||
|
|
1aac3ab49f | ||
|
|
78e1d58d3a | ||
|
|
c44c21060e | ||
|
|
ce34cccf28 | ||
|
|
d27d925a6d | ||
|
|
481ce92bdf | ||
|
|
84bbac5a09 | ||
|
|
ee8e3ee919 | ||
|
|
de24bd960f | ||
|
|
d2c450ce81 | ||
|
|
474d1c57c8 | ||
|
|
9b4c072a04 | ||
|
|
766f65919b | ||
|
|
482f2b31e7 | ||
|
|
6b404431aa | ||
|
|
4e9ca75281 | ||
|
|
bcd5fc12ec | ||
|
|
56ea65ca5f | ||
|
|
5fee2e1a79 | ||
|
|
9cd30d30a0 | ||
|
|
83c44229d2 | ||
|
|
21e20cb4ad | ||
|
|
4dada747e5 | ||
|
|
4f2e8bc765 | ||
|
|
fb0eba706c | ||
|
|
27963980db | ||
|
|
d3c042fc60 | ||
|
|
fcd878efcd | ||
|
|
3f9c848576 | ||
|
|
ddc865fb0d | ||
|
|
c03e872112 | ||
|
|
abee3d0e0d | ||
|
|
d55268d0d4 | ||
|
|
5adfa44101 | ||
|
|
1d61416b5a | ||
|
|
08137c28c4 | ||
|
|
bb50fdfe07 | ||
|
|
ec5631b6d6 | ||
|
|
7b55c7f97d | ||
|
|
8e5b6f58a2 | ||
|
|
299c5c379e | ||
|
|
3b4921674e | ||
|
|
f7be20e70c | ||
|
|
fcfb5c04bb | ||
|
|
e4bc603f0b | ||
|
|
ef36c04ccf | ||
|
|
f882f08627 | ||
|
|
528a8b9769 | ||
|
|
4baed3a080 | ||
|
|
e3cbfb91d2 | ||
|
|
94e3365b8f | ||
|
|
88adfcd178 | ||
|
|
ee87ebf381 | ||
|
|
26b6fba9d3 | ||
|
|
619879246d | ||
|
|
fff145dba3 | ||
|
|
f77f369ce8 | ||
|
|
c794c51a1a | ||
|
|
0163111325 | ||
|
|
9ad2cb3f1a | ||
|
|
4ca2965b99 | ||
|
|
2cd4a747e5 | ||
|
|
d7e2e127a9 | ||
|
|
2afabe8b83 | ||
|
|
191836845e | ||
|
|
75aa615bef | ||
|
|
9cb220be9d | ||
|
|
a96425fe82 | ||
|
|
b851c42a14 | ||
|
|
f3fca91e9f | ||
|
|
c689fcfdb0 | ||
|
|
5f934b0785 | ||
|
|
d0bbbdcd6e | ||
|
|
7221c8c22d | ||
|
|
2bec513996 | ||
|
|
7ab3699b58 | ||
|
|
ab801874f8 | ||
|
|
8003e266ed | ||
|
|
8723a94c25 | ||
|
|
5cb40bbbd3 | ||
|
|
4c13922961 | ||
|
|
e2532ab5f2 | ||
|
|
1796e2c495 | ||
|
|
6672c8e480 | ||
|
|
b539c8452f | ||
|
|
64309f8669 | ||
|
|
745cd17926 | ||
|
|
c253778de9 | ||
|
|
35ff74676b | ||
|
|
41f5add965 | ||
|
|
1aa7e477b1 | ||
|
|
79c6904faf | ||
|
|
186c2b3d0e | ||
|
|
30297a5b83 | ||
|
|
bd9a48bc9c | ||
|
|
4e1e720523 | ||
|
|
ed270a5f32 | ||
|
|
b1bac0dab2 | ||
|
|
a09300a88c | ||
|
|
7c9d533a85 | ||
|
|
6446c2d4ab | ||
|
|
72e76044cf | ||
|
|
a8875efa85 | ||
|
|
dd8bbfd084 | ||
|
|
fe5e23bf75 | ||
|
|
c3c6659f12 | ||
|
|
d2023283ac | ||
|
|
1da0ad13fb | ||
|
|
96702ca945 | ||
|
|
8ec6ee47f1 | ||
|
|
5bc593ccb8 | ||
|
|
cccdc4e01a | ||
|
|
835068637e | ||
|
|
f962a0354e | ||
|
|
f23c3f95e8 | ||
|
|
fff9b699f1 | ||
|
|
3831c91c95 | ||
|
|
e85dbae389 | ||
|
|
ff2b6d2185 | ||
|
|
6884f665bd | ||
|
|
68af8e7a08 | ||
|
|
b559105cfb | ||
|
|
7d75a96b15 | ||
|
|
705eaf8b40 | ||
|
|
9cdfd14223 | ||
|
|
223bc97f61 | ||
|
|
c881c733bb | ||
|
|
ed6a49c657 | ||
|
|
2a587df80a | ||
|
|
49d15890e0 | ||
|
|
e13bd362e3 | ||
|
|
dbd18f639c | ||
|
|
70ab28f907 | ||
|
|
fbe5f39f0f | ||
|
|
16aec39ebe | ||
|
|
8512862163 | ||
|
|
7e3a5f58bc | ||
|
|
7c2db5c198 | ||
|
|
a702457eac | ||
|
|
e8979889b4 | ||
|
|
01cd9570c7 | ||
|
|
a6899c3587 | ||
|
|
6d38dc3af4 | ||
|
|
f430cdbf2e | ||
|
|
1fe4e9e573 | ||
|
|
ae6bf96659 | ||
|
|
9d6c46955f | ||
|
|
8d0a734d91 | ||
|
|
3d461676a9 | ||
|
|
a89d50fb9a | ||
|
|
130f559f4d | ||
|
|
05c8c4f745 | ||
|
|
72cc9641f8 | ||
|
|
40276648ab | ||
|
|
6df9e3c9a3 | ||
|
|
059c91711f | ||
|
|
4bfb84db4e | ||
|
|
e5569cb52e | ||
|
|
40702dac93 | ||
|
|
f6ccc62c70 | ||
|
|
5cc6459c46 | ||
|
|
73cb1fdfea | ||
|
|
e7fca5125a | ||
|
|
b4f608d8e0 | ||
|
|
d031b203c7 | ||
|
|
9bd8d0c23e | ||
|
|
599bbfbd9b | ||
|
|
abbd363261 | ||
|
|
53bd4015aa | ||
|
|
459a2ba1ef | ||
|
|
49cce2b838 | ||
|
|
6e1b62b18c | ||
|
|
a29a5e40ae | ||
|
|
cb12cb2407 | ||
|
|
5281630229 | ||
|
|
6bef3d1d22 | ||
|
|
1bec1b980e | ||
|
|
cd0fbb5e77 | ||
|
|
ef66d75704 | ||
|
|
018b155ad9 | ||
|
|
cb981638f5 | ||
|
|
f8b21d0933 | ||
|
|
15c3885688 | ||
|
|
9fcd799b98 | ||
|
|
3a3e50e3db |
No files matched your search
@@ -111,7 +111,7 @@ config LOCALE_SUPPORT
|
||||
busybox to support locale settings.
|
||||
|
||||
config GETOPT_LONG
|
||||
bool "Enable support for --long-options"
|
||||
bool "Support for --long-options"
|
||||
default y
|
||||
help
|
||||
Enable this if you want busybox applets to use the gnu --long-option
|
||||
@@ -280,6 +280,17 @@ config STATIC
|
||||
|
||||
Most people will leave this set to 'N'.
|
||||
|
||||
config NOMMU
|
||||
bool "Force NOMMU build"
|
||||
default n
|
||||
help
|
||||
Busybox tries to detect whether architecture it is being
|
||||
built against supports MMU or not. If this detection fails,
|
||||
or if you want to build NOMMU version of busybox for testing,
|
||||
you may force NOMMU build here.
|
||||
|
||||
Most people will leave this set to 'N'.
|
||||
|
||||
config BUILD_LIBBUSYBOX
|
||||
bool "Build shared libbusybox"
|
||||
default n
|
||||
@@ -555,4 +566,4 @@ source shell/Config.in
|
||||
source sysklogd/Config.in
|
||||
source runit/Config.in
|
||||
source selinux/Config.in
|
||||
source ipsvd/Config.in
|
||||
source printutils/Config.in
|
||||
@@ -1,6 +1,6 @@
|
||||
VERSION = 1
|
||||
PATCHLEVEL = 8
|
||||
SUBLEVEL = 0
|
||||
PATCHLEVEL = 10
|
||||
SUBLEVEL = 4
|
||||
EXTRAVERSION =
|
||||
NAME = Unnamed
|
||||
|
||||
@@ -437,7 +437,6 @@ libs-y := \
|
||||
editors/ \
|
||||
findutils/ \
|
||||
init/ \
|
||||
ipsvd/ \
|
||||
libbb/ \
|
||||
libpwdgrp/ \
|
||||
loginutils/ \
|
||||
@@ -446,12 +445,14 @@ libs-y := \
|
||||
networking/ \
|
||||
networking/libiproute/ \
|
||||
networking/udhcp/ \
|
||||
printutils/ \
|
||||
procps/ \
|
||||
runit/ \
|
||||
selinux/ \
|
||||
shell/ \
|
||||
sysklogd/ \
|
||||
util-linux/ \
|
||||
util-linux/volume_id/ \
|
||||
|
||||
endif # KBUILD_EXTMOD
|
||||
|
||||
@@ -571,6 +572,7 @@ quiet_cmd_busybox__ ?= LINK $@
|
||||
cmd_busybox__ ?= $(srctree)/scripts/trylink \
|
||||
"$@" \
|
||||
"$(CC)" \
|
||||
"$(CFLAGS)" \
|
||||
"$(LDFLAGS) $(EXTRA_LDFLAGS)" \
|
||||
"$(core-y)" \
|
||||
"$(libs-y)" \
|
||||
@@ -729,7 +731,7 @@ localver = $(subst $(space),, \
|
||||
# Currently, only git is supported.
|
||||
# Other SCMs can edit scripts/setlocalversion and add the appropriate
|
||||
# checks as needed.
|
||||
ifdef CONFIG_LOCALVERSION_AUTO
|
||||
ifdef _BB_DISABLED_CONFIG_LOCALVERSION_AUTO
|
||||
_localver-auto = $(shell $(CONFIG_SHELL) \
|
||||
$(srctree)/scripts/setlocalversion $(srctree))
|
||||
localver-auto = $(LOCALVERSION)$(_localver-auto)
|
||||
@@ -842,7 +844,7 @@ depend dep:
|
||||
# ---------------------------------------------------------------------------
|
||||
# Modules
|
||||
|
||||
ifdef CONFIG_MODULES
|
||||
ifdef _BB_DISABLED_CONFIG_MODULES
|
||||
|
||||
# By default, build modules as well
|
||||
|
||||
@@ -928,6 +930,8 @@ MRPROPER_FILES += .config .config.old include/asm .version .old_version \
|
||||
include/autoconf.h \
|
||||
include/bbconfigopts.h \
|
||||
include/usage_compressed.h \
|
||||
include/applet_tables.h \
|
||||
applets/usage \
|
||||
.kernelrelease Module.symvers tags TAGS cscope*
|
||||
|
||||
# clean - Delete most, but leave enough to build external modules
|
||||
|
||||
+1
-1
@@ -90,7 +90,7 @@ objsizes: busybox_unstripped
|
||||
|
||||
.PHONY: stksizes
|
||||
stksizes: busybox_unstripped
|
||||
$(CROSS_COMPILE)objdump -d busybox_unstripped | $(srctree)/scripts/checkstack.pl $(ARCH)
|
||||
$(CROSS_COMPILE)objdump -d busybox_unstripped | $(srctree)/scripts/checkstack.pl $(ARCH) | uniq
|
||||
|
||||
.PHONY: bigdata
|
||||
bigdata: busybox_unstripped
|
||||
|
||||
+3
-1
@@ -20,6 +20,7 @@ CPPFLAGS += \
|
||||
# flag checks are grouped together to speed the checks up a bit..
|
||||
CFLAGS += $(call cc-option,-Wall -Wshadow -Wwrite-strings,)
|
||||
CFLAGS += $(call cc-option,-Wundef -Wstrict-prototypes,)
|
||||
CFLAGS += $(call cc-option,-Wunused -Wunused-parameter,)
|
||||
# If you want to add "-Wmissing-prototypes -Wmissing-declarations" above
|
||||
# (or anything else for that matter) make sure that it is still possible
|
||||
# to build bbox without warnings. Current offender: find.c:alloc_action().
|
||||
@@ -97,4 +98,5 @@ endif
|
||||
# Busybox is a stack-fatty so make sure we increase default size
|
||||
# TODO: use "make stksizes" to find & fix big stack users
|
||||
# (we stole scripts/checkstack.pl from the kernel... thanks guys!)
|
||||
FLTFLAGS += -s 20000
|
||||
# Reduced from 20k to 16k in 1.9.0.
|
||||
FLTFLAGS += -s 16000
|
||||
+2
-3
@@ -16,7 +16,6 @@ help:
|
||||
@echo 'Configuration:'
|
||||
@echo ' allnoconfig - disable all symbols in .config'
|
||||
@echo ' allyesconfig - enable all symbols in .config (see defconfig)'
|
||||
@echo ' allbareconfig - enable all applets without any sub-features'
|
||||
@echo ' config - text based configurator (of last resort)'
|
||||
@echo ' defconfig - set .config to largest generic configuration'
|
||||
@echo ' menuconfig - interactive curses-based configurator'
|
||||
@@ -24,10 +23,10 @@ help:
|
||||
@echo ' hosttools - build sed for the host.'
|
||||
@echo ' You can use these commands if the commands on the host'
|
||||
@echo ' is unusable. Afterwards use it like:'
|
||||
@echo ' make SED="$(objtree)/sed"'
|
||||
@echo ' make SED="$(objtree)/sed"'
|
||||
@echo
|
||||
@echo 'Installation:'
|
||||
@echo ' install - install busybox into $(CONFIG_PREFIX)'
|
||||
@echo ' install - install busybox into CONFIG_PREFIX'
|
||||
@echo ' uninstall'
|
||||
@echo
|
||||
@echo 'Development:'
|
||||
|
||||
@@ -82,6 +82,9 @@ Downloading the current source code:
|
||||
is generally a faster way of getting it fixed, and the complete archive of
|
||||
what happened is the subversion changelog.
|
||||
|
||||
Note: if you want to compile busybox in a busybox environment you must
|
||||
select ENABLE_DESKTOP.
|
||||
|
||||
----------------
|
||||
|
||||
getting help:
|
||||
|
||||
@@ -7,27 +7,21 @@ have any suggestions how they plan to go about it, and to minimize conflicts
|
||||
between your work and theirs. But otherwise, all of these are fair game.
|
||||
|
||||
Rob Landley <rob@landley.net>:
|
||||
Add BB_NOMMU to platform.h and migrate __uClinux__ tests to that.
|
||||
#if defined __UCLIBC__ && !defined __ARCH_USE_MMU__
|
||||
Add a libbb/platform.c
|
||||
Implement fdprintf() for platforms that haven't got one.
|
||||
Implement bb_realpath() that can handle NULL on non-glibc.
|
||||
Cleanup bb_asprintf()
|
||||
|
||||
Migrate calloc() and bb_calloc() occurrences to bb_xzalloc().
|
||||
Remove obsolete _() wrapper crud for internationalization we don't do.
|
||||
Figure out where we need utf8 support, and add it.
|
||||
|
||||
sh
|
||||
The command shell situation is a big mess. We have three or four different
|
||||
The command shell situation is a big mess. We have three different
|
||||
shells that don't really share any code, and the "standalone shell" doesn't
|
||||
work all that well (especially not in a chroot environment), due to apps not
|
||||
being reentrant. I'm writing a new shell (bbsh) to unify the various
|
||||
shells and configurably add the minimal set of bash features people
|
||||
actually use. The hardest part is it has to configure down as small as
|
||||
lash while providing lash's features. The rest is easy in comparison.
|
||||
bzip2
|
||||
Compression-side support.
|
||||
being reentrant.
|
||||
lash is phased out. hush can be configured down to be nearly as small,
|
||||
but less buggy :)
|
||||
init
|
||||
General cleanup (should use ENABLE_FEATURE_INIT_SYSLOG and ENABLE_FEATURE_INIT_DEBUG).
|
||||
depmod
|
||||
@@ -35,8 +29,6 @@ Rob Landley <rob@landley.net>:
|
||||
use of the depmod.pl (perl is to bloated for most embedded setups) and or orig
|
||||
modutils. The orig depmod is rather pointless to have to add to a firmware image
|
||||
in when we already have a insmod/rmmod and friends.
|
||||
Unify base64 handling.
|
||||
[done]
|
||||
Do a SUSv3 audit
|
||||
Look at the full Single Unix Specification version 3 (available online at
|
||||
"http://www.opengroup.org/onlinepubs/009695399/nfindex.html") and
|
||||
@@ -128,9 +120,6 @@ Bernhard Fischer <busybox@busybox.net> suggests to look at these:
|
||||
|
||||
As yet unclaimed:
|
||||
|
||||
----
|
||||
find
|
||||
doesn't understand (), lots of susv3 stuff.
|
||||
----
|
||||
diff
|
||||
Make sure we handle empty files properly:
|
||||
@@ -148,10 +137,6 @@ patch
|
||||
And while we're at it, a new patch filename quoting format is apparently
|
||||
coming soon: http://marc.theaimsgroup.com/?l=git&m=112927316408690&w=2
|
||||
---
|
||||
ps / top
|
||||
Add support for both RSS and VSIZE rather than just one or the other.
|
||||
Or make it a build option.
|
||||
---
|
||||
man
|
||||
It would be nice to have a man command. Not one that handles troff or
|
||||
anything, just one that can handle preformatted ascii man pages, possibly
|
||||
@@ -306,15 +291,15 @@ Minor stuff:
|
||||
---
|
||||
Move __get_hz() to a better place and (re)use it in route.c, ash.c, msh.c
|
||||
---
|
||||
See grep -r strtod
|
||||
Alot of duplication that wants cleanup.
|
||||
---
|
||||
|
||||
|
||||
Code cleanup:
|
||||
|
||||
Replace deprecated functions.
|
||||
|
||||
bzero() -> memset()
|
||||
---
|
||||
sigblock(), siggetmask(), sigsetmask(), sigmask() -> sigprocmask et al
|
||||
---
|
||||
vdprintf() -> similar sized functionality
|
||||
---
|
||||
+239
-112
@@ -1,11 +1,7 @@
|
||||
# This .config compiles for NOMMU.
|
||||
# TODO:
|
||||
# Pick disabled applet, enable & try to make it compile & work on NOMMU
|
||||
|
||||
#
|
||||
# Automatically generated make config: don't edit
|
||||
# Busybox version: 1.6.0.svn
|
||||
# Wed Apr 11 01:29:04 2007
|
||||
# Busybox version: 1.10.0.svn
|
||||
# Thu Mar 20 14:54:21 2008
|
||||
#
|
||||
CONFIG_HAVE_DOT_CONFIG=y
|
||||
|
||||
@@ -16,9 +12,9 @@ CONFIG_HAVE_DOT_CONFIG=y
|
||||
#
|
||||
# General Configuration
|
||||
#
|
||||
# CONFIG_NITPICK is not set
|
||||
# CONFIG_DESKTOP is not set
|
||||
# CONFIG_FEATURE_BUFFERS_USE_MALLOC is not set
|
||||
CONFIG_NITPICK=y
|
||||
CONFIG_DESKTOP=y
|
||||
CONFIG_FEATURE_BUFFERS_USE_MALLOC=y
|
||||
# CONFIG_FEATURE_BUFFERS_GO_ON_STACK is not set
|
||||
# CONFIG_FEATURE_BUFFERS_GO_IN_BSS is not set
|
||||
CONFIG_SHOW_USAGE=y
|
||||
@@ -31,29 +27,29 @@ CONFIG_FEATURE_DEVPTS=y
|
||||
# CONFIG_FEATURE_CLEAN_UP is not set
|
||||
CONFIG_FEATURE_PIDFILE=y
|
||||
CONFIG_FEATURE_SUID=y
|
||||
CONFIG_FEATURE_SYSLOG=y
|
||||
# CONFIG_FEATURE_SUID_CONFIG is not set
|
||||
# CONFIG_FEATURE_SUID_CONFIG_QUIET is not set
|
||||
# CONFIG_FEATURE_HAVE_RPC is not set
|
||||
# CONFIG_SELINUX is not set
|
||||
CONFIG_FEATURE_SUID_CONFIG=y
|
||||
CONFIG_FEATURE_SUID_CONFIG_QUIET=y
|
||||
CONFIG_SELINUX=y
|
||||
CONFIG_FEATURE_PREFER_APPLETS=y
|
||||
CONFIG_BUSYBOX_EXEC_PATH="/proc/self/exe"
|
||||
CONFIG_FEATURE_SYSLOG=y
|
||||
CONFIG_FEATURE_HAVE_RPC=y
|
||||
|
||||
#
|
||||
# Build Options
|
||||
#
|
||||
# CONFIG_STATIC is not set
|
||||
CONFIG_NOMMU=y
|
||||
# CONFIG_BUILD_LIBBUSYBOX is not set
|
||||
# CONFIG_FEATURE_FULL_LIBBUSYBOX is not set
|
||||
# CONFIG_FEATURE_INDIVIDUAL is not set
|
||||
# CONFIG_FEATURE_SHARED_BUSYBOX is not set
|
||||
CONFIG_LFS=y
|
||||
# CONFIG_BUILD_AT_ONCE is not set
|
||||
|
||||
#
|
||||
# Debugging Options
|
||||
#
|
||||
# CONFIG_DEBUG is not set
|
||||
CONFIG_WERROR=y
|
||||
# CONFIG_WERROR is not set
|
||||
CONFIG_NO_DEBUG_LIB=y
|
||||
# CONFIG_DMALLOC is not set
|
||||
# CONFIG_EFENCE is not set
|
||||
@@ -65,7 +61,11 @@ CONFIG_INCLUDE_SUSv2=y
|
||||
# CONFIG_INSTALL_NO_USR is not set
|
||||
CONFIG_INSTALL_APPLET_SYMLINKS=y
|
||||
# CONFIG_INSTALL_APPLET_HARDLINKS is not set
|
||||
# CONFIG_INSTALL_APPLET_SCRIPT_WRAPPERS is not set
|
||||
# CONFIG_INSTALL_APPLET_DONT is not set
|
||||
# CONFIG_INSTALL_SH_APPLET_SYMLINK is not set
|
||||
# CONFIG_INSTALL_SH_APPLET_HARDLINK is not set
|
||||
# CONFIG_INSTALL_SH_APPLET_SCRIPT_WRAPPER is not set
|
||||
CONFIG_PREFIX="./_install"
|
||||
|
||||
#
|
||||
@@ -73,14 +73,20 @@ CONFIG_PREFIX="./_install"
|
||||
#
|
||||
CONFIG_PASSWORD_MINLEN=6
|
||||
CONFIG_MD5_SIZE_VS_SPEED=2
|
||||
CONFIG_FEATURE_FAST_TOP=y
|
||||
CONFIG_FEATURE_ETC_NETWORKS=y
|
||||
CONFIG_FEATURE_EDITING=y
|
||||
# CONFIG_FEATURE_EDITING_FANCY_KEYS is not set
|
||||
# CONFIG_FEATURE_EDITING_VI is not set
|
||||
CONFIG_FEATURE_EDITING_MAX_LEN=1024
|
||||
CONFIG_FEATURE_EDITING_VI=y
|
||||
CONFIG_FEATURE_EDITING_HISTORY=15
|
||||
# CONFIG_FEATURE_EDITING_SAVEHISTORY is not set
|
||||
# CONFIG_FEATURE_TAB_COMPLETION is not set
|
||||
# CONFIG_FEATURE_USERNAME_COMPLETION is not set
|
||||
# CONFIG_FEATURE_EDITING_FANCY_PROMPT is not set
|
||||
CONFIG_FEATURE_TAB_COMPLETION=y
|
||||
CONFIG_FEATURE_USERNAME_COMPLETION=y
|
||||
CONFIG_FEATURE_EDITING_FANCY_PROMPT=y
|
||||
CONFIG_FEATURE_VERBOSE_CP_MESSAGE=y
|
||||
CONFIG_FEATURE_COPYBUF_KB=4
|
||||
CONFIG_MONOTONIC_SYSCALL=y
|
||||
CONFIG_IOCTL_HEX2STR_ERROR=y
|
||||
|
||||
#
|
||||
# Applets
|
||||
@@ -92,25 +98,30 @@ CONFIG_FEATURE_EDITING_HISTORY=15
|
||||
CONFIG_AR=y
|
||||
CONFIG_FEATURE_AR_LONG_FILENAMES=y
|
||||
CONFIG_BUNZIP2=y
|
||||
CONFIG_BZIP2=y
|
||||
CONFIG_CPIO=y
|
||||
# CONFIG_DPKG is not set
|
||||
# CONFIG_DPKG_DEB is not set
|
||||
# CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY is not set
|
||||
CONFIG_DPKG=y
|
||||
CONFIG_DPKG_DEB=y
|
||||
CONFIG_FEATURE_DPKG_DEB_EXTRACT_ONLY=y
|
||||
CONFIG_GUNZIP=y
|
||||
CONFIG_FEATURE_GUNZIP_UNCOMPRESS=y
|
||||
CONFIG_GZIP=y
|
||||
CONFIG_RPM2CPIO=y
|
||||
# CONFIG_RPM is not set
|
||||
CONFIG_RPM=y
|
||||
CONFIG_FEATURE_RPM_BZ2=y
|
||||
CONFIG_TAR=y
|
||||
CONFIG_FEATURE_TAR_CREATE=y
|
||||
# CONFIG_FEATURE_TAR_BZIP2 is not set
|
||||
# CONFIG_FEATURE_TAR_LZMA is not set
|
||||
CONFIG_FEATURE_TAR_GZIP=y
|
||||
CONFIG_FEATURE_TAR_BZIP2=y
|
||||
CONFIG_FEATURE_TAR_LZMA=y
|
||||
CONFIG_FEATURE_TAR_COMPRESS=y
|
||||
CONFIG_FEATURE_TAR_AUTODETECT=y
|
||||
CONFIG_FEATURE_TAR_FROM=y
|
||||
# CONFIG_FEATURE_TAR_GZIP is not set
|
||||
# CONFIG_FEATURE_TAR_COMPRESS is not set
|
||||
CONFIG_FEATURE_TAR_OLDGNU_COMPATIBILITY=y
|
||||
CONFIG_FEATURE_TAR_OLDSUN_COMPATIBILITY=y
|
||||
CONFIG_FEATURE_TAR_GNU_EXTENSIONS=y
|
||||
CONFIG_FEATURE_TAR_LONG_OPTIONS=y
|
||||
CONFIG_FEATURE_TAR_UNAME_GNAME=y
|
||||
CONFIG_UNCOMPRESS=y
|
||||
CONFIG_UNLZMA=y
|
||||
CONFIG_FEATURE_LZMA_FAST=y
|
||||
@@ -120,9 +131,13 @@ CONFIG_UNZIP=y
|
||||
# Common options for cpio and tar
|
||||
#
|
||||
CONFIG_FEATURE_UNARCHIVE_TAPE=y
|
||||
# CONFIG_FEATURE_DEB_TAR_GZ is not set
|
||||
# CONFIG_FEATURE_DEB_TAR_BZ2 is not set
|
||||
# CONFIG_FEATURE_DEB_TAR_LZMA is not set
|
||||
|
||||
#
|
||||
# Common options for dpkg and dpkg_deb
|
||||
#
|
||||
CONFIG_FEATURE_DEB_TAR_GZ=y
|
||||
CONFIG_FEATURE_DEB_TAR_BZ2=y
|
||||
CONFIG_FEATURE_DEB_TAR_LZMA=y
|
||||
|
||||
#
|
||||
# Coreutils
|
||||
@@ -136,7 +151,6 @@ CONFIG_CHMOD=y
|
||||
CONFIG_CHOWN=y
|
||||
CONFIG_CHROOT=y
|
||||
CONFIG_CKSUM=y
|
||||
CONFIG_CMP=y
|
||||
CONFIG_COMM=y
|
||||
CONFIG_CP=y
|
||||
CONFIG_CUT=y
|
||||
@@ -146,10 +160,7 @@ CONFIG_DD=y
|
||||
CONFIG_FEATURE_DD_SIGNAL_HANDLING=y
|
||||
CONFIG_FEATURE_DD_IBS_OBS=y
|
||||
CONFIG_DF=y
|
||||
CONFIG_DIFF=y
|
||||
CONFIG_FEATURE_DIFF_BINARY=y
|
||||
CONFIG_FEATURE_DIFF_DIR=y
|
||||
CONFIG_FEATURE_DIFF_MINIMAL=y
|
||||
CONFIG_FEATURE_DF_INODE=y
|
||||
CONFIG_DIRNAME=y
|
||||
CONFIG_DOS2UNIX=y
|
||||
CONFIG_UNIX2DOS=y
|
||||
@@ -159,6 +170,8 @@ CONFIG_ECHO=y
|
||||
CONFIG_FEATURE_FANCY_ECHO=y
|
||||
CONFIG_ENV=y
|
||||
CONFIG_FEATURE_ENV_LONG_OPTIONS=y
|
||||
CONFIG_EXPAND=y
|
||||
CONFIG_FEATURE_EXPAND_LONG_OPTIONS=y
|
||||
CONFIG_EXPR=y
|
||||
CONFIG_EXPR_MATH_SUPPORT_64=y
|
||||
CONFIG_FALSE=y
|
||||
@@ -194,9 +207,12 @@ CONFIG_OD=y
|
||||
CONFIG_PRINTENV=y
|
||||
CONFIG_PRINTF=y
|
||||
CONFIG_PWD=y
|
||||
CONFIG_READLINK=y
|
||||
CONFIG_FEATURE_READLINK_FOLLOW=y
|
||||
CONFIG_REALPATH=y
|
||||
CONFIG_RM=y
|
||||
CONFIG_RMDIR=y
|
||||
CONFIG_FEATURE_RMDIR_LONG_OPTIONS=y
|
||||
CONFIG_SEQ=y
|
||||
CONFIG_SHA1SUM=y
|
||||
CONFIG_SLEEP=y
|
||||
@@ -210,6 +226,7 @@ CONFIG_FEATURE_STAT_FORMAT=y
|
||||
CONFIG_STTY=y
|
||||
CONFIG_SUM=y
|
||||
CONFIG_SYNC=y
|
||||
CONFIG_TAC=y
|
||||
CONFIG_TAIL=y
|
||||
CONFIG_FEATURE_FANCY_TAIL=y
|
||||
CONFIG_TEE=y
|
||||
@@ -223,11 +240,12 @@ CONFIG_FEATURE_TR_EQUIV=y
|
||||
CONFIG_TRUE=y
|
||||
CONFIG_TTY=y
|
||||
CONFIG_UNAME=y
|
||||
CONFIG_UNEXPAND=y
|
||||
CONFIG_FEATURE_UNEXPAND_LONG_OPTIONS=y
|
||||
CONFIG_UNIQ=y
|
||||
CONFIG_USLEEP=y
|
||||
CONFIG_UUDECODE=y
|
||||
CONFIG_UUENCODE=y
|
||||
CONFIG_WATCH=y
|
||||
CONFIG_WC=y
|
||||
CONFIG_FEATURE_WC_LARGE=y
|
||||
CONFIG_WHO=y
|
||||
@@ -261,6 +279,7 @@ CONFIG_CHVT=y
|
||||
CONFIG_CLEAR=y
|
||||
CONFIG_DEALLOCVT=y
|
||||
CONFIG_DUMPKMAP=y
|
||||
CONFIG_KBD_MODE=y
|
||||
CONFIG_LOADFONT=y
|
||||
CONFIG_LOADKMAP=y
|
||||
CONFIG_OPENVT=y
|
||||
@@ -277,14 +296,12 @@ CONFIG_SETLOGCONS=y
|
||||
#
|
||||
CONFIG_MKTEMP=y
|
||||
CONFIG_PIPE_PROGRESS=y
|
||||
CONFIG_READLINK=y
|
||||
CONFIG_FEATURE_READLINK_FOLLOW=y
|
||||
CONFIG_RUN_PARTS=y
|
||||
CONFIG_FEATURE_RUN_PARTS_LONG_OPTIONS=y
|
||||
CONFIG_FEATURE_RUN_PARTS_FANCY=y
|
||||
# CONFIG_START_STOP_DAEMON is not set
|
||||
# CONFIG_FEATURE_START_STOP_DAEMON_FANCY is not set
|
||||
# CONFIG_FEATURE_START_STOP_DAEMON_LONG_OPTIONS is not set
|
||||
CONFIG_START_STOP_DAEMON=y
|
||||
CONFIG_FEATURE_START_STOP_DAEMON_FANCY=y
|
||||
CONFIG_FEATURE_START_STOP_DAEMON_LONG_OPTIONS=y
|
||||
CONFIG_WHICH=y
|
||||
|
||||
#
|
||||
@@ -292,10 +309,17 @@ CONFIG_WHICH=y
|
||||
#
|
||||
CONFIG_AWK=y
|
||||
CONFIG_FEATURE_AWK_MATH=y
|
||||
CONFIG_CMP=y
|
||||
CONFIG_DIFF=y
|
||||
CONFIG_FEATURE_DIFF_BINARY=y
|
||||
CONFIG_FEATURE_DIFF_DIR=y
|
||||
CONFIG_FEATURE_DIFF_MINIMAL=y
|
||||
CONFIG_ED=y
|
||||
CONFIG_PATCH=y
|
||||
CONFIG_SED=y
|
||||
CONFIG_VI=y
|
||||
CONFIG_FEATURE_VI_MAX_LEN=4096
|
||||
CONFIG_FEATURE_VI_8BIT=y
|
||||
CONFIG_FEATURE_VI_COLON=y
|
||||
CONFIG_FEATURE_VI_YANKMARK=y
|
||||
CONFIG_FEATURE_VI_SEARCH=y
|
||||
@@ -318,6 +342,7 @@ CONFIG_FEATURE_FIND_MMIN=y
|
||||
CONFIG_FEATURE_FIND_PERM=y
|
||||
CONFIG_FEATURE_FIND_TYPE=y
|
||||
CONFIG_FEATURE_FIND_XDEV=y
|
||||
CONFIG_FEATURE_FIND_MAXDEPTH=y
|
||||
CONFIG_FEATURE_FIND_NEWER=y
|
||||
CONFIG_FEATURE_FIND_INUM=y
|
||||
CONFIG_FEATURE_FIND_EXEC=y
|
||||
@@ -328,6 +353,10 @@ CONFIG_FEATURE_FIND_DEPTH=y
|
||||
CONFIG_FEATURE_FIND_PAREN=y
|
||||
CONFIG_FEATURE_FIND_SIZE=y
|
||||
CONFIG_FEATURE_FIND_PRUNE=y
|
||||
CONFIG_FEATURE_FIND_DELETE=y
|
||||
CONFIG_FEATURE_FIND_PATH=y
|
||||
CONFIG_FEATURE_FIND_REGEX=y
|
||||
CONFIG_FEATURE_FIND_CONTEXT=y
|
||||
CONFIG_GREP=y
|
||||
CONFIG_FEATURE_GREP_EGREP_ALIAS=y
|
||||
CONFIG_FEATURE_GREP_FGREP_ALIAS=y
|
||||
@@ -341,14 +370,16 @@ CONFIG_FEATURE_XARGS_SUPPORT_ZERO_TERM=y
|
||||
#
|
||||
# Init Utilities
|
||||
#
|
||||
# CONFIG_INIT is not set
|
||||
CONFIG_INIT=y
|
||||
# CONFIG_DEBUG_INIT is not set
|
||||
# CONFIG_FEATURE_USE_INITTAB is not set
|
||||
# CONFIG_FEATURE_INIT_SCTTY is not set
|
||||
# CONFIG_FEATURE_INIT_SYSLOG is not set
|
||||
# CONFIG_FEATURE_EXTRA_QUIET is not set
|
||||
# CONFIG_FEATURE_INIT_COREDUMPS is not set
|
||||
# CONFIG_FEATURE_INITRD is not set
|
||||
CONFIG_FEATURE_USE_INITTAB=y
|
||||
CONFIG_FEATURE_KILL_REMOVED=y
|
||||
CONFIG_FEATURE_KILL_DELAY=1
|
||||
CONFIG_FEATURE_INIT_SCTTY=y
|
||||
CONFIG_FEATURE_INIT_SYSLOG=y
|
||||
CONFIG_FEATURE_EXTRA_QUIET=y
|
||||
CONFIG_FEATURE_INIT_COREDUMPS=y
|
||||
CONFIG_FEATURE_INITRD=y
|
||||
CONFIG_HALT=y
|
||||
CONFIG_MESG=y
|
||||
|
||||
@@ -361,16 +392,23 @@ CONFIG_USE_BB_PWD_GRP=y
|
||||
CONFIG_ADDGROUP=y
|
||||
CONFIG_FEATURE_ADDUSER_TO_GROUP=y
|
||||
CONFIG_DELGROUP=y
|
||||
CONFIG_FEATURE_DEL_USER_FROM_GROUP=y
|
||||
CONFIG_FEATURE_CHECK_NAMES=y
|
||||
CONFIG_ADDUSER=y
|
||||
CONFIG_FEATURE_ADDUSER_LONG_OPTIONS=y
|
||||
CONFIG_DELUSER=y
|
||||
CONFIG_GETTY=y
|
||||
CONFIG_FEATURE_UTMP=y
|
||||
CONFIG_FEATURE_WTMP=y
|
||||
CONFIG_LOGIN=y
|
||||
# CONFIG_PAM is not set
|
||||
CONFIG_LOGIN_SCRIPTS=y
|
||||
CONFIG_FEATURE_NOLOGIN=y
|
||||
CONFIG_FEATURE_SECURETTY=y
|
||||
CONFIG_PASSWD=y
|
||||
CONFIG_FEATURE_PASSWD_WEAK_CHECK=y
|
||||
CONFIG_CRYPTPW=y
|
||||
CONFIG_CHPASSWD=y
|
||||
CONFIG_SU=y
|
||||
CONFIG_FEATURE_SU_SYSLOG=y
|
||||
CONFIG_FEATURE_SU_CHECKS_SHELLS=y
|
||||
@@ -426,6 +464,7 @@ CONFIG_FEATURE_SGI_LABEL=y
|
||||
CONFIG_FEATURE_SUN_LABEL=y
|
||||
CONFIG_FEATURE_OSF_LABEL=y
|
||||
CONFIG_FEATURE_FDISK_ADVANCED=y
|
||||
CONFIG_FINDFS=y
|
||||
CONFIG_FREERAMDISK=y
|
||||
CONFIG_FSCK_MINIX=y
|
||||
CONFIG_MKFS_MINIX=y
|
||||
@@ -436,6 +475,8 @@ CONFIG_MKFS_MINIX=y
|
||||
CONFIG_FEATURE_MINIX2=y
|
||||
CONFIG_GETOPT=y
|
||||
CONFIG_HEXDUMP=y
|
||||
CONFIG_FEATURE_HEXDUMP_REVERSE=y
|
||||
CONFIG_HD=y
|
||||
CONFIG_HWCLOCK=y
|
||||
CONFIG_FEATURE_HWCLOCK_LONG_OPTIONS=y
|
||||
CONFIG_FEATURE_HWCLOCK_ADJTIME_FHS=y
|
||||
@@ -444,19 +485,43 @@ CONFIG_IPCS=y
|
||||
CONFIG_LOSETUP=y
|
||||
CONFIG_MDEV=y
|
||||
CONFIG_FEATURE_MDEV_CONF=y
|
||||
CONFIG_FEATURE_MDEV_RENAME=y
|
||||
CONFIG_FEATURE_MDEV_EXEC=y
|
||||
CONFIG_FEATURE_MDEV_LOAD_FIRMWARE=y
|
||||
CONFIG_MKSWAP=y
|
||||
CONFIG_FEATURE_MKSWAP_V0=y
|
||||
CONFIG_MORE=y
|
||||
CONFIG_FEATURE_USE_TERMIOS=y
|
||||
CONFIG_VOLUMEID=y
|
||||
CONFIG_FEATURE_VOLUMEID_EXT=y
|
||||
CONFIG_FEATURE_VOLUMEID_REISERFS=y
|
||||
CONFIG_FEATURE_VOLUMEID_FAT=y
|
||||
CONFIG_FEATURE_VOLUMEID_HFS=y
|
||||
CONFIG_FEATURE_VOLUMEID_JFS=y
|
||||
CONFIG_FEATURE_VOLUMEID_XFS=y
|
||||
CONFIG_FEATURE_VOLUMEID_NTFS=y
|
||||
CONFIG_FEATURE_VOLUMEID_ISO9660=y
|
||||
CONFIG_FEATURE_VOLUMEID_UDF=y
|
||||
CONFIG_FEATURE_VOLUMEID_LUKS=y
|
||||
CONFIG_FEATURE_VOLUMEID_LINUXSWAP=y
|
||||
CONFIG_FEATURE_VOLUMEID_CRAMFS=y
|
||||
CONFIG_FEATURE_VOLUMEID_ROMFS=y
|
||||
CONFIG_FEATURE_VOLUMEID_SYSV=y
|
||||
CONFIG_FEATURE_VOLUMEID_OCFS2=y
|
||||
CONFIG_FEATURE_VOLUMEID_LINUXRAID=y
|
||||
CONFIG_MOUNT=y
|
||||
# CONFIG_FEATURE_MOUNT_NFS is not set
|
||||
CONFIG_FEATURE_MOUNT_FAKE=y
|
||||
CONFIG_FEATURE_MOUNT_VERBOSE=y
|
||||
CONFIG_FEATURE_MOUNT_HELPERS=y
|
||||
CONFIG_FEATURE_MOUNT_LABEL=y
|
||||
CONFIG_FEATURE_MOUNT_NFS=y
|
||||
CONFIG_FEATURE_MOUNT_CIFS=y
|
||||
CONFIG_FEATURE_MOUNT_FLAGS=y
|
||||
CONFIG_FEATURE_MOUNT_FSTAB=y
|
||||
CONFIG_PIVOT_ROOT=y
|
||||
CONFIG_RDATE=y
|
||||
CONFIG_READPROFILE=y
|
||||
CONFIG_RTCWAKE=y
|
||||
CONFIG_SETARCH=y
|
||||
CONFIG_SWAPONOFF=y
|
||||
CONFIG_SWITCH_ROOT=y
|
||||
@@ -473,12 +538,20 @@ CONFIG_FEATURE_MOUNT_LOOP=y
|
||||
# Miscellaneous Utilities
|
||||
#
|
||||
CONFIG_ADJTIMEX=y
|
||||
# CONFIG_BBCONFIG is not set
|
||||
CONFIG_BBCONFIG=y
|
||||
CONFIG_CHAT=y
|
||||
CONFIG_FEATURE_CHAT_NOFAIL=y
|
||||
CONFIG_FEATURE_CHAT_TTY_HIFI=y
|
||||
CONFIG_FEATURE_CHAT_IMPLICIT_CR=y
|
||||
CONFIG_FEATURE_CHAT_SWALLOW_OPTS=y
|
||||
CONFIG_FEATURE_CHAT_SEND_ESCAPES=y
|
||||
CONFIG_FEATURE_CHAT_VAR_ABORT_LEN=y
|
||||
CONFIG_FEATURE_CHAT_CLR_ABORT=y
|
||||
CONFIG_CHRT=y
|
||||
# CONFIG_CROND is not set
|
||||
# CONFIG_DEBUG_CROND_OPTION is not set
|
||||
# CONFIG_FEATURE_CROND_CALL_SENDMAIL is not set
|
||||
# CONFIG_CRONTAB is not set
|
||||
CONFIG_CROND=y
|
||||
CONFIG_DEBUG_CROND_OPTION=y
|
||||
CONFIG_FEATURE_CROND_CALL_SENDMAIL=y
|
||||
CONFIG_CRONTAB=y
|
||||
CONFIG_DC=y
|
||||
# CONFIG_DEVFSD is not set
|
||||
# CONFIG_DEVFSD_MODLOAD is not set
|
||||
@@ -486,6 +559,7 @@ CONFIG_DC=y
|
||||
# CONFIG_DEVFSD_VERBOSE is not set
|
||||
# CONFIG_FEATURE_DEVFS is not set
|
||||
CONFIG_EJECT=y
|
||||
CONFIG_FEATURE_EJECT_SCSI=y
|
||||
CONFIG_LAST=y
|
||||
CONFIG_LESS=y
|
||||
CONFIG_FEATURE_LESS_MAXLINES=9999999
|
||||
@@ -504,27 +578,32 @@ CONFIG_FEATURE_HDPARM_HDIO_GETSET_DMA=y
|
||||
CONFIG_MAKEDEVS=y
|
||||
# CONFIG_FEATURE_MAKEDEVS_LEAF is not set
|
||||
CONFIG_FEATURE_MAKEDEVS_TABLE=y
|
||||
CONFIG_MICROCOM=y
|
||||
CONFIG_MOUNTPOINT=y
|
||||
CONFIG_MT=y
|
||||
CONFIG_NMETER=y
|
||||
CONFIG_RAIDAUTORUN=y
|
||||
CONFIG_READAHEAD=y
|
||||
CONFIG_RUNLEVEL=y
|
||||
CONFIG_RX=y
|
||||
CONFIG_SCRIPT=y
|
||||
CONFIG_STRINGS=y
|
||||
CONFIG_SETSID=y
|
||||
# CONFIG_TASKSET is not set
|
||||
# CONFIG_FEATURE_TASKSET_FANCY is not set
|
||||
CONFIG_TASKSET=y
|
||||
CONFIG_FEATURE_TASKSET_FANCY=y
|
||||
CONFIG_TIME=y
|
||||
CONFIG_TTYSIZE=y
|
||||
CONFIG_WATCHDOG=y
|
||||
|
||||
#
|
||||
# Networking Utilities
|
||||
#
|
||||
CONFIG_FEATURE_IPV6=y
|
||||
# CONFIG_VERBOSE_RESOLUTION_ERRORS is not set
|
||||
CONFIG_FEATURE_PREFER_IPV4_ADDRESS=y
|
||||
CONFIG_VERBOSE_RESOLUTION_ERRORS=y
|
||||
CONFIG_ARP=y
|
||||
CONFIG_ARPING=y
|
||||
CONFIG_BRCTL=y
|
||||
CONFIG_FEATURE_BRCTL_FANCY=y
|
||||
CONFIG_DNSD=y
|
||||
CONFIG_ETHER_WAKE=y
|
||||
CONFIG_FAKEIDENTD=y
|
||||
@@ -532,37 +611,43 @@ CONFIG_FTPGET=y
|
||||
CONFIG_FTPPUT=y
|
||||
CONFIG_FEATURE_FTPGETPUT_LONG_OPTIONS=y
|
||||
CONFIG_HOSTNAME=y
|
||||
# CONFIG_HTTPD is not set
|
||||
# CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP is not set
|
||||
# CONFIG_FEATURE_HTTPD_SETUID is not set
|
||||
# CONFIG_FEATURE_HTTPD_BASIC_AUTH is not set
|
||||
# CONFIG_FEATURE_HTTPD_AUTH_MD5 is not set
|
||||
# CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES is not set
|
||||
# CONFIG_FEATURE_HTTPD_CGI is not set
|
||||
# CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR is not set
|
||||
# CONFIG_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV is not set
|
||||
# CONFIG_FEATURE_HTTPD_ENCODE_URL_STR is not set
|
||||
CONFIG_HTTPD=y
|
||||
CONFIG_FEATURE_HTTPD_RANGES=y
|
||||
CONFIG_FEATURE_HTTPD_USE_SENDFILE=y
|
||||
CONFIG_FEATURE_HTTPD_RELOAD_CONFIG_SIGHUP=y
|
||||
CONFIG_FEATURE_HTTPD_SETUID=y
|
||||
CONFIG_FEATURE_HTTPD_BASIC_AUTH=y
|
||||
CONFIG_FEATURE_HTTPD_AUTH_MD5=y
|
||||
CONFIG_FEATURE_HTTPD_CONFIG_WITH_MIME_TYPES=y
|
||||
CONFIG_FEATURE_HTTPD_CGI=y
|
||||
CONFIG_FEATURE_HTTPD_CONFIG_WITH_SCRIPT_INTERPR=y
|
||||
CONFIG_FEATURE_HTTPD_SET_REMOTE_PORT_TO_ENV=y
|
||||
CONFIG_FEATURE_HTTPD_ENCODE_URL_STR=y
|
||||
CONFIG_FEATURE_HTTPD_ERROR_PAGES=y
|
||||
CONFIG_FEATURE_HTTPD_PROXY=y
|
||||
CONFIG_IFCONFIG=y
|
||||
CONFIG_FEATURE_IFCONFIG_STATUS=y
|
||||
CONFIG_FEATURE_IFCONFIG_SLIP=y
|
||||
CONFIG_FEATURE_IFCONFIG_MEMSTART_IOADDR_IRQ=y
|
||||
CONFIG_FEATURE_IFCONFIG_HW=y
|
||||
CONFIG_FEATURE_IFCONFIG_BROADCAST_PLUS=y
|
||||
# CONFIG_IFUPDOWN is not set
|
||||
# CONFIG_FEATURE_IFUPDOWN_IP is not set
|
||||
# CONFIG_FEATURE_IFUPDOWN_IP_BUILTIN is not set
|
||||
CONFIG_IFENSLAVE=y
|
||||
CONFIG_IFUPDOWN=y
|
||||
CONFIG_IFUPDOWN_IFSTATE_PATH="/var/run/ifstate"
|
||||
CONFIG_FEATURE_IFUPDOWN_IP=y
|
||||
CONFIG_FEATURE_IFUPDOWN_IP_BUILTIN=y
|
||||
# CONFIG_FEATURE_IFUPDOWN_IFCONFIG_BUILTIN is not set
|
||||
# CONFIG_FEATURE_IFUPDOWN_IPV4 is not set
|
||||
# CONFIG_FEATURE_IFUPDOWN_IPV6 is not set
|
||||
# CONFIG_FEATURE_IFUPDOWN_IPX is not set
|
||||
# CONFIG_FEATURE_IFUPDOWN_MAPPING is not set
|
||||
# CONFIG_INETD is not set
|
||||
# CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO is not set
|
||||
# CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD is not set
|
||||
# CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME is not set
|
||||
# CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME is not set
|
||||
# CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN is not set
|
||||
# CONFIG_FEATURE_INETD_RPC is not set
|
||||
CONFIG_FEATURE_IFUPDOWN_IPV4=y
|
||||
CONFIG_FEATURE_IFUPDOWN_IPV6=y
|
||||
CONFIG_FEATURE_IFUPDOWN_MAPPING=y
|
||||
CONFIG_FEATURE_IFUPDOWN_EXTERNAL_DHCP=y
|
||||
CONFIG_INETD=y
|
||||
CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_ECHO=y
|
||||
CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DISCARD=y
|
||||
CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_TIME=y
|
||||
CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_DAYTIME=y
|
||||
CONFIG_FEATURE_INETD_SUPPORT_BUILTIN_CHARGEN=y
|
||||
CONFIG_FEATURE_INETD_RPC=y
|
||||
CONFIG_IP=y
|
||||
CONFIG_FEATURE_IP_ADDRESS=y
|
||||
CONFIG_FEATURE_IP_LINK=y
|
||||
@@ -570,6 +655,7 @@ CONFIG_FEATURE_IP_ROUTE=y
|
||||
CONFIG_FEATURE_IP_TUNNEL=y
|
||||
CONFIG_FEATURE_IP_RULE=y
|
||||
CONFIG_FEATURE_IP_SHORT_FORMS=y
|
||||
CONFIG_FEATURE_IP_RARE_PROTOCOLS=y
|
||||
CONFIG_IPADDR=y
|
||||
CONFIG_IPLINK=y
|
||||
CONFIG_IPROUTE=y
|
||||
@@ -579,41 +665,56 @@ CONFIG_IPCALC=y
|
||||
CONFIG_FEATURE_IPCALC_FANCY=y
|
||||
CONFIG_FEATURE_IPCALC_LONG_OPTIONS=y
|
||||
CONFIG_NAMEIF=y
|
||||
CONFIG_FEATURE_NAMEIF_EXTENDED=y
|
||||
CONFIG_NC=y
|
||||
CONFIG_NC_SERVER=y
|
||||
CONFIG_NC_EXTRA=y
|
||||
CONFIG_NETSTAT=y
|
||||
CONFIG_FEATURE_NETSTAT_WIDE=y
|
||||
CONFIG_NSLOOKUP=y
|
||||
CONFIG_PING=y
|
||||
CONFIG_PING6=y
|
||||
CONFIG_FEATURE_FANCY_PING=y
|
||||
CONFIG_PSCAN=y
|
||||
CONFIG_ROUTE=y
|
||||
CONFIG_SENDMAIL=y
|
||||
CONFIG_FETCHMAIL=y
|
||||
CONFIG_SLATTACH=y
|
||||
CONFIG_TELNET=y
|
||||
CONFIG_FEATURE_TELNET_TTYPE=y
|
||||
CONFIG_FEATURE_TELNET_AUTOLOGIN=y
|
||||
# CONFIG_TELNETD is not set
|
||||
# CONFIG_FEATURE_TELNETD_STANDALONE is not set
|
||||
CONFIG_TELNETD=y
|
||||
CONFIG_FEATURE_TELNETD_STANDALONE=y
|
||||
CONFIG_TFTP=y
|
||||
CONFIG_TFTPD=y
|
||||
CONFIG_FEATURE_TFTP_GET=y
|
||||
CONFIG_FEATURE_TFTP_PUT=y
|
||||
CONFIG_FEATURE_TFTP_BLOCKSIZE=y
|
||||
# CONFIG_DEBUG_TFTP is not set
|
||||
CONFIG_DEBUG_TFTP=y
|
||||
CONFIG_TRACEROUTE=y
|
||||
# CONFIG_FEATURE_TRACEROUTE_VERBOSE is not set
|
||||
# CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE is not set
|
||||
# CONFIG_FEATURE_TRACEROUTE_USE_ICMP is not set
|
||||
CONFIG_FEATURE_TRACEROUTE_VERBOSE=y
|
||||
CONFIG_FEATURE_TRACEROUTE_SOURCE_ROUTE=y
|
||||
CONFIG_FEATURE_TRACEROUTE_USE_ICMP=y
|
||||
CONFIG_APP_UDHCPD=y
|
||||
CONFIG_APP_DHCPRELAY=y
|
||||
CONFIG_APP_DUMPLEASES=y
|
||||
# CONFIG_APP_UDHCPC is not set
|
||||
# CONFIG_FEATURE_UDHCP_DEBUG is not set
|
||||
CONFIG_FEATURE_UDHCPD_WRITE_LEASES_EARLY=y
|
||||
CONFIG_DHCPD_LEASES_FILE="/var/lib/misc/udhcpd.leases"
|
||||
CONFIG_APP_UDHCPC=y
|
||||
CONFIG_FEATURE_UDHCPC_ARPING=y
|
||||
CONFIG_FEATURE_UDHCP_PORT=y
|
||||
CONFIG_FEATURE_UDHCP_DEBUG=y
|
||||
CONFIG_FEATURE_RFC3397=y
|
||||
CONFIG_DHCPC_DEFAULT_SCRIPT="/usr/share/udhcpc/default.script"
|
||||
CONFIG_UDHCPC_SLACK_FOR_BUGGY_SERVERS=80
|
||||
CONFIG_VCONFIG=y
|
||||
CONFIG_WGET=y
|
||||
CONFIG_FEATURE_WGET_STATUSBAR=y
|
||||
CONFIG_FEATURE_WGET_AUTHENTICATION=y
|
||||
CONFIG_FEATURE_WGET_LONG_OPTIONS=y
|
||||
CONFIG_ZCIP=y
|
||||
CONFIG_TCPSVD=y
|
||||
CONFIG_UDPSVD=y
|
||||
|
||||
#
|
||||
# Process Utilities
|
||||
@@ -623,23 +724,31 @@ CONFIG_FUSER=y
|
||||
CONFIG_KILL=y
|
||||
CONFIG_KILLALL=y
|
||||
CONFIG_KILLALL5=y
|
||||
CONFIG_NMETER=y
|
||||
CONFIG_PGREP=y
|
||||
CONFIG_PIDOF=y
|
||||
CONFIG_FEATURE_PIDOF_SINGLE=y
|
||||
CONFIG_FEATURE_PIDOF_OMIT=y
|
||||
CONFIG_PKILL=y
|
||||
CONFIG_PS=y
|
||||
CONFIG_FEATURE_PS_WIDE=y
|
||||
CONFIG_FEATURE_PS_TIME=y
|
||||
CONFIG_FEATURE_PS_UNUSUAL_SYSTEMS=y
|
||||
CONFIG_RENICE=y
|
||||
CONFIG_BB_SYSCTL=y
|
||||
CONFIG_TOP=y
|
||||
CONFIG_FEATURE_TOP_CPU_USAGE_PERCENTAGE=y
|
||||
CONFIG_FEATURE_TOP_CPU_GLOBAL_PERCENTS=y
|
||||
CONFIG_FEATURE_TOP_DECIMALS=y
|
||||
CONFIG_FEATURE_TOPMEM=y
|
||||
CONFIG_UPTIME=y
|
||||
CONFIG_WATCH=y
|
||||
|
||||
#
|
||||
# Shells
|
||||
#
|
||||
# CONFIG_FEATURE_SH_IS_ASH is not set
|
||||
# CONFIG_FEATURE_SH_IS_HUSH is not set
|
||||
# CONFIG_FEATURE_SH_IS_LASH is not set
|
||||
# CONFIG_FEATURE_SH_IS_MSH is not set
|
||||
CONFIG_FEATURE_SH_IS_NONE=y
|
||||
# CONFIG_ASH is not set
|
||||
@@ -657,8 +766,14 @@ CONFIG_FEATURE_SH_IS_NONE=y
|
||||
# CONFIG_ASH_OPTIMIZE_FOR_SIZE is not set
|
||||
# CONFIG_ASH_RANDOM_SUPPORT is not set
|
||||
# CONFIG_ASH_EXPAND_PRMT is not set
|
||||
# CONFIG_HUSH is not set
|
||||
# CONFIG_LASH is not set
|
||||
CONFIG_HUSH=y
|
||||
CONFIG_HUSH_HELP=y
|
||||
CONFIG_HUSH_INTERACTIVE=y
|
||||
CONFIG_HUSH_JOB=y
|
||||
CONFIG_HUSH_TICK=y
|
||||
CONFIG_HUSH_IF=y
|
||||
CONFIG_HUSH_LOOPS=y
|
||||
CONFIG_LASH=y
|
||||
CONFIG_MSH=y
|
||||
|
||||
#
|
||||
@@ -666,6 +781,7 @@ CONFIG_MSH=y
|
||||
#
|
||||
CONFIG_FEATURE_SH_EXTRA_QUIET=y
|
||||
CONFIG_FEATURE_SH_STANDALONE=y
|
||||
CONFIG_CTTYHACK=y
|
||||
|
||||
#
|
||||
# System Logging Utilities
|
||||
@@ -673,6 +789,7 @@ CONFIG_FEATURE_SH_STANDALONE=y
|
||||
CONFIG_SYSLOGD=y
|
||||
CONFIG_FEATURE_ROTATE_LOGFILE=y
|
||||
CONFIG_FEATURE_REMOTE_LOG=y
|
||||
CONFIG_FEATURE_SYSLOGD_DUP=y
|
||||
CONFIG_FEATURE_IPC_SYSLOG=y
|
||||
CONFIG_FEATURE_IPC_SYSLOG_BUFFER_SIZE=16
|
||||
CONFIG_LOGREAD=y
|
||||
@@ -683,28 +800,38 @@ CONFIG_LOGGER=y
|
||||
#
|
||||
# Runit Utilities
|
||||
#
|
||||
# CONFIG_RUNSV is not set
|
||||
# CONFIG_RUNSVDIR is not set
|
||||
CONFIG_RUNSV=y
|
||||
CONFIG_RUNSVDIR=y
|
||||
CONFIG_SV=y
|
||||
# CONFIG_SVLOGD is not set
|
||||
CONFIG_SVLOGD=y
|
||||
CONFIG_CHPST=y
|
||||
CONFIG_SETUIDGID=y
|
||||
CONFIG_ENVUIDGID=y
|
||||
CONFIG_ENVDIR=y
|
||||
CONFIG_SOFTLIMIT=y
|
||||
# CONFIG_CHCON is not set
|
||||
# CONFIG_FEATURE_CHCON_LONG_OPTIONS is not set
|
||||
# CONFIG_GETENFORCE is not set
|
||||
# CONFIG_GETSEBOOL is not set
|
||||
# CONFIG_LOAD_POLICY is not set
|
||||
# CONFIG_MATCHPATHCON is not set
|
||||
# CONFIG_RUNCON is not set
|
||||
# CONFIG_FEATURE_RUNCON_LONG_OPTIONS is not set
|
||||
# CONFIG_SELINUXENABLED is not set
|
||||
# CONFIG_SETENFORCE is not set
|
||||
|
||||
#
|
||||
# ipsvd utilities
|
||||
# Selinux Utilities
|
||||
#
|
||||
# CONFIG_TCPSVD is not set
|
||||
# CONFIG_UDPSVD is not set
|
||||
CONFIG_CHCON=y
|
||||
CONFIG_FEATURE_CHCON_LONG_OPTIONS=y
|
||||
CONFIG_GETENFORCE=y
|
||||
CONFIG_GETSEBOOL=y
|
||||
CONFIG_LOAD_POLICY=y
|
||||
CONFIG_MATCHPATHCON=y
|
||||
CONFIG_RESTORECON=y
|
||||
CONFIG_RUNCON=y
|
||||
CONFIG_FEATURE_RUNCON_LONG_OPTIONS=y
|
||||
CONFIG_SELINUXENABLED=y
|
||||
CONFIG_SETENFORCE=y
|
||||
CONFIG_SETFILES=y
|
||||
CONFIG_FEATURE_SETFILES_CHECK_OPTION=y
|
||||
CONFIG_SETSEBOOL=y
|
||||
CONFIG_SESTATUS=y
|
||||
|
||||
#
|
||||
# Print Utilities
|
||||
#
|
||||
CONFIG_LPD=y
|
||||
CONFIG_LPR=y
|
||||
CONFIG_LPQ=y
|
||||
+14
-5
@@ -8,18 +8,27 @@ obj-y :=
|
||||
obj-y += applets.o
|
||||
|
||||
hostprogs-y:=
|
||||
hostprogs-y += usage
|
||||
hostprogs-y += usage applet_tables
|
||||
|
||||
always:= $(hostprogs-y)
|
||||
|
||||
# Generated files need additional love
|
||||
|
||||
HOSTCFLAGS_usage.o = -I$(srctree)/include
|
||||
|
||||
applets/applets.o: include/usage_compressed.h include/applet_tables.h
|
||||
|
||||
applets/usage: .config $(srctree)/applets/usage_compressed
|
||||
applets/applet_tables: .config
|
||||
|
||||
quiet_cmd_gen_usage_compressed = GEN include/usage_compressed.h
|
||||
cmd_gen_usage_compressed = $(srctree)/applets/usage_compressed include/usage_compressed.h applets
|
||||
|
||||
HOSTCFLAGS_usage.o = -I$(srctree)/include
|
||||
|
||||
applets/applets.o: include/usage_compressed.h
|
||||
applets/usage: .config $(srctree)/applets/usage_compressed
|
||||
include/usage_compressed.h: applets/usage $(srctree)/applets/usage_compressed
|
||||
$(call cmd,gen_usage_compressed)
|
||||
|
||||
quiet_cmd_gen_applet_tables = GEN include/applet_tables.h
|
||||
cmd_gen_applet_tables = applets/applet_tables include/applet_tables.h
|
||||
|
||||
include/applet_tables.h: applets/applet_tables
|
||||
$(call cmd,gen_applet_tables)
|
||||
@@ -0,0 +1,115 @@
|
||||
/* vi: set sw=4 ts=4: */
|
||||
/*
|
||||
* Applet table generator.
|
||||
* Runs on host and produces include/applet_tables.h
|
||||
*
|
||||
* Copyright (C) 2007 Denys Vlasenko <vda.linux@googlemail.com>
|
||||
*
|
||||
* Licensed under GPLv2, see file License in this tarball for details.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "../include/autoconf.h"
|
||||
#include "../include/busybox.h"
|
||||
|
||||
struct bb_applet {
|
||||
const char *name;
|
||||
const char *main;
|
||||
enum bb_install_loc_t install_loc;
|
||||
enum bb_suid_t need_suid;
|
||||
/* true if instead of fork(); exec("applet"); waitpid();
|
||||
* one can do fork(); exit(applet_main(argc,argv)); waitpid(); */
|
||||
unsigned char noexec;
|
||||
/* Even nicer */
|
||||
/* true if instead of fork(); exec("applet"); waitpid();
|
||||
* one can simply call applet_main(argc,argv); */
|
||||
unsigned char nofork;
|
||||
};
|
||||
|
||||
/* Define struct bb_applet applets[] */
|
||||
#include "../include/applets.h"
|
||||
|
||||
enum { NUM_APPLETS = ARRAY_SIZE(applets) };
|
||||
|
||||
static int offset[NUM_APPLETS];
|
||||
|
||||
static int cmp_name(const void *a, const void *b)
|
||||
{
|
||||
const struct bb_applet *aa = a;
|
||||
const struct bb_applet *bb = b;
|
||||
return strcmp(aa->name, bb->name);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int i;
|
||||
int ofs;
|
||||
|
||||
qsort(applets, NUM_APPLETS, sizeof(applets[0]), cmp_name);
|
||||
|
||||
ofs = 0;
|
||||
for (i = 0; i < NUM_APPLETS; i++) {
|
||||
offset[i] = ofs;
|
||||
ofs += strlen(applets[i].name) + 1;
|
||||
}
|
||||
/* We reuse 4 high-order bits of offset array for other purposes,
|
||||
* so if they are indeed needed, refuse to proceed */
|
||||
if (ofs > 0xfff)
|
||||
return 1;
|
||||
if (!argv[1])
|
||||
return 1;
|
||||
|
||||
i = open(argv[1], O_WRONLY | O_TRUNC | O_CREAT, 0666);
|
||||
if (i < 0)
|
||||
return 1;
|
||||
dup2(i, 1);
|
||||
|
||||
/* Keep in sync with include/busybox.h! */
|
||||
|
||||
puts("/* This is a generated file, don't edit */");
|
||||
|
||||
puts("const char applet_names[] ALIGN1 = \"\"\n");
|
||||
for (i = 0; i < NUM_APPLETS; i++) {
|
||||
printf("\"%s\" \"\\0\"\n", applets[i].name);
|
||||
}
|
||||
puts(";");
|
||||
|
||||
puts("int (*const applet_main[])(int argc, char **argv) = {");
|
||||
for (i = 0; i < NUM_APPLETS; i++) {
|
||||
printf("%s_main,\n", applets[i].main);
|
||||
}
|
||||
puts("};");
|
||||
|
||||
puts("const uint16_t applet_nameofs[] ALIGN2 = {");
|
||||
for (i = 0; i < NUM_APPLETS; i++) {
|
||||
printf("0x%04x,\n",
|
||||
offset[i]
|
||||
#if ENABLE_FEATURE_PREFER_APPLETS
|
||||
+ (applets[i].nofork << 12)
|
||||
+ (applets[i].noexec << 13)
|
||||
#endif
|
||||
#if ENABLE_FEATURE_SUID
|
||||
+ (applets[i].need_suid << 14) /* 2 bits */
|
||||
#endif
|
||||
);
|
||||
}
|
||||
puts("};");
|
||||
|
||||
#if ENABLE_FEATURE_INSTALLER
|
||||
puts("const uint8_t applet_install_loc[] ALIGN1 = {");
|
||||
i = 0;
|
||||
while (i < NUM_APPLETS) {
|
||||
int v = applets[i].install_loc; /* 3 bits */
|
||||
if (++i < NUM_APPLETS)
|
||||
v |= applets[i].install_loc << 4; /* 3 bits */
|
||||
printf("0x%02x,\n", v);
|
||||
i++;
|
||||
}
|
||||
puts("};");
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
+3
-14
@@ -2,7 +2,7 @@
|
||||
/*
|
||||
* Stub for linking busybox binary against libbusybox.
|
||||
*
|
||||
* Copyright (C) 2007 Denis Vlasenko
|
||||
* Copyright (C) 2007 Denys Vlasenko <vda.linux@googlemail.com>
|
||||
*
|
||||
* Licensed under GPLv2, see file License in this tarball for details.
|
||||
*/
|
||||
@@ -10,20 +10,9 @@
|
||||
#include <assert.h>
|
||||
#include "busybox.h"
|
||||
|
||||
/* Apparently uclibc defines __GLIBC__ (compat trick?). Oh well. */
|
||||
#if ENABLE_STATIC && defined(__GLIBC__) && !defined(__UCLIBC__)
|
||||
#warning Static linking against glibc produces buggy executables
|
||||
#warning (glibc does not cope well with ld --gc-sections).
|
||||
#warning See sources.redhat.com/bugzilla/show_bug.cgi?id=3400
|
||||
#warning Note that glibc is unsuitable for static linking anyway.
|
||||
#warning If you still want to do it, remove -Wl,--gc-sections
|
||||
#warning from top-level Makefile and remove this warning.
|
||||
#error Aborting compilation.
|
||||
#endif
|
||||
|
||||
#if ENABLE_BUILD_LIBBUSYBOX
|
||||
int main(int argc, char **argv)
|
||||
int main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
return lbb_main(argc, argv);
|
||||
return lbb_main(argv);
|
||||
}
|
||||
#endif
|
||||
@@ -12,8 +12,16 @@ sz=`"$loc/usage" | wc -c` || exit 1
|
||||
|
||||
exec >"$target"
|
||||
|
||||
echo 'static const char packed_usage[] ALIGN1 = '
|
||||
"$loc/usage" | bzip2 -1 | od -v -t x1 \
|
||||
| $SED -e 's/^[^ ]*//' -e 's/ *\(..\)/\\x\1/g' -e 's/^\(.*\)$/"\1"/'
|
||||
echo ';'
|
||||
echo 'static const char packed_usage[] ALIGN1 = {'
|
||||
|
||||
# Extra effort to avoid using "od -t x1": -t is not available
|
||||
# in non-CONFIG_DESKTOPed busybox od
|
||||
|
||||
"$loc/usage" | bzip2 -1 | od -v -x \
|
||||
| $SED -e 's/^[^ ]*//' \
|
||||
| $SED -e 's/ //g' \
|
||||
| grep -v '^$' \
|
||||
| $SED -e 's/\(..\)\(..\)/0x\2,0x\1,/g'
|
||||
|
||||
echo '};'
|
||||
echo '#define SIZEOF_usage_messages' `expr 0 + $sz`
|
||||
+38
-21
@@ -29,7 +29,7 @@ config AR
|
||||
probably say N here.
|
||||
|
||||
config FEATURE_AR_LONG_FILENAMES
|
||||
bool "Enable support for long filenames (not need for debs)"
|
||||
bool "Support for long filenames (not need for debs)"
|
||||
default n
|
||||
depends on AR
|
||||
help
|
||||
@@ -99,7 +99,7 @@ config DPKG_DEB
|
||||
probably say N here.
|
||||
|
||||
config FEATURE_DPKG_DEB_EXTRACT_ONLY
|
||||
bool "extract only (-x)"
|
||||
bool "Extract only (-x)"
|
||||
default n
|
||||
depends on DPKG_DEB
|
||||
help
|
||||
@@ -166,6 +166,14 @@ config FEATURE_TAR_CREATE
|
||||
If you enable this option you'll be able to create
|
||||
tar archives using the `-c' option.
|
||||
|
||||
config FEATURE_TAR_GZIP
|
||||
bool "Enable -z option"
|
||||
default y
|
||||
depends on TAR
|
||||
help
|
||||
If you enable this option tar will be able to call gzip,
|
||||
when creating or extracting tar gziped archives.
|
||||
|
||||
config FEATURE_TAR_BZIP2
|
||||
bool "Enable -j option to handle .tar.bz2 files"
|
||||
default n
|
||||
@@ -182,22 +190,6 @@ config FEATURE_TAR_LZMA
|
||||
If you enable this option you'll be able to extract
|
||||
archives compressed with lzma.
|
||||
|
||||
config FEATURE_TAR_FROM
|
||||
bool "Enable -X (exclude from) and -T (include from) options)"
|
||||
default n
|
||||
depends on TAR
|
||||
help
|
||||
If you enable this option you'll be able to specify
|
||||
a list of files to include or exclude from an archive.
|
||||
|
||||
config FEATURE_TAR_GZIP
|
||||
bool "Enable -z option"
|
||||
default y
|
||||
depends on TAR
|
||||
help
|
||||
If you enable this option tar will be able to call gzip,
|
||||
when creating or extracting tar gziped archives.
|
||||
|
||||
config FEATURE_TAR_COMPRESS
|
||||
bool "Enable -Z option"
|
||||
default n
|
||||
@@ -206,8 +198,24 @@ config FEATURE_TAR_COMPRESS
|
||||
If you enable this option tar will be able to call uncompress,
|
||||
when extracting .tar.Z archives.
|
||||
|
||||
config FEATURE_TAR_AUTODETECT
|
||||
bool "Let tar autodetect gz/bz2 compresses tarballs"
|
||||
default n
|
||||
depends on FEATURE_TAR_GZIP || FEATURE_TAR_BZIP2
|
||||
help
|
||||
With this option tar can automatically detect gzip/bzip2 compressed
|
||||
tarballs. Currently it works only on seekable streams.
|
||||
|
||||
config FEATURE_TAR_FROM
|
||||
bool "Enable -X (exclude from) and -T (include from) options)"
|
||||
default n
|
||||
depends on TAR
|
||||
help
|
||||
If you enable this option you'll be able to specify
|
||||
a list of files to include or exclude from an archive.
|
||||
|
||||
config FEATURE_TAR_OLDGNU_COMPATIBILITY
|
||||
bool "Enable support for old tar header format"
|
||||
bool "Support for old tar header format"
|
||||
default N
|
||||
depends on TAR
|
||||
help
|
||||
@@ -225,7 +233,7 @@ config FEATURE_TAR_OLDSUN_COMPATIBILITY
|
||||
It is said to be fixed in newer Sun tar, but "old" tarballs still exist.
|
||||
|
||||
config FEATURE_TAR_GNU_EXTENSIONS
|
||||
bool "Enable support for some GNU tar extensions"
|
||||
bool "Support for GNU tar extensions (long filenames)"
|
||||
default y
|
||||
depends on TAR
|
||||
help
|
||||
@@ -237,7 +245,16 @@ config FEATURE_TAR_LONG_OPTIONS
|
||||
default n
|
||||
depends on TAR && GETOPT_LONG
|
||||
help
|
||||
Enable use of long options, increases size by about 400 Bytes
|
||||
Enable use of long options, increases size by about 400 Bytes
|
||||
|
||||
config FEATURE_TAR_UNAME_GNAME
|
||||
bool "Enable use of user and group names"
|
||||
default n
|
||||
depends on TAR
|
||||
help
|
||||
Enables use of user and group names in tar. This affects contents
|
||||
listings (-t) and preserving permissions when unpacking (-p).
|
||||
+200 bytes.
|
||||
|
||||
config UNCOMPRESS
|
||||
bool "uncompress"
|
||||
|
||||
+4
-4
@@ -159,7 +159,7 @@ USE_DESKTOP(long long) int unpack_bunzip2(void)
|
||||
}
|
||||
|
||||
int bunzip2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int bunzip2_main(int argc, char **argv)
|
||||
int bunzip2_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
getopt32(argv, "cfvdt");
|
||||
argv += optind;
|
||||
@@ -257,7 +257,7 @@ USE_DESKTOP(long long) int unpack_gunzip(void)
|
||||
}
|
||||
|
||||
int gunzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int gunzip_main(int argc, char **argv)
|
||||
int gunzip_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
getopt32(argv, "cfvdt");
|
||||
argv += optind;
|
||||
@@ -295,7 +295,7 @@ USE_DESKTOP(long long) int unpack_unlzma(void)
|
||||
}
|
||||
|
||||
int unlzma_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int unlzma_main(int argc, char **argv)
|
||||
int unlzma_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
getopt32(argv, "cf");
|
||||
argv += optind;
|
||||
@@ -337,7 +337,7 @@ USE_DESKTOP(long long) int unpack_uncompress(void)
|
||||
}
|
||||
|
||||
int uncompress_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int uncompress_main(int argc, char **argv)
|
||||
int uncompress_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
getopt32(argv, "cf");
|
||||
argv += optind;
|
||||
|
||||
+15
-6
@@ -721,7 +721,8 @@ void mainQSort3(uint32_t* ptr,
|
||||
#define CLEARMASK (~(SETMASK))
|
||||
|
||||
static NOINLINE
|
||||
void mainSort(uint32_t* ptr,
|
||||
void mainSort(EState* state,
|
||||
uint32_t* ptr,
|
||||
uint8_t* block,
|
||||
uint16_t* quadrant,
|
||||
uint32_t* ftab,
|
||||
@@ -729,13 +730,18 @@ void mainSort(uint32_t* ptr,
|
||||
int32_t* budget)
|
||||
{
|
||||
int32_t i, j, k, ss, sb;
|
||||
int32_t runningOrder[256];
|
||||
Bool bigDone[256];
|
||||
int32_t copyStart[256];
|
||||
int32_t copyEnd [256];
|
||||
uint8_t c1;
|
||||
int32_t numQSorted;
|
||||
uint16_t s;
|
||||
Bool bigDone[256];
|
||||
/* bbox: moved to EState to save stack
|
||||
int32_t runningOrder[256];
|
||||
int32_t copyStart[256];
|
||||
int32_t copyEnd [256];
|
||||
*/
|
||||
#define runningOrder (state->mainSort__runningOrder)
|
||||
#define copyStart (state->mainSort__copyStart)
|
||||
#define copyEnd (state->mainSort__copyEnd)
|
||||
|
||||
/*-- set up the 2-byte frequency table --*/
|
||||
/* was: for (i = 65536; i >= 0; i--) ftab[i] = 0; */
|
||||
@@ -985,6 +991,9 @@ void mainSort(uint32_t* ptr,
|
||||
AssertH(((bbSize-1) >> shifts) <= 65535, 1002);
|
||||
}
|
||||
}
|
||||
#undef runningOrder
|
||||
#undef copyStart
|
||||
#undef copyEnd
|
||||
}
|
||||
|
||||
#undef BIGFREQ
|
||||
@@ -1041,7 +1050,7 @@ void BZ2_blockSort(EState* s)
|
||||
*/
|
||||
budget = nblock * ((wfact-1) / 3);
|
||||
|
||||
mainSort(ptr, block, quadrant, ftab, nblock, &budget);
|
||||
mainSort(s, ptr, block, quadrant, ftab, nblock, &budget);
|
||||
if (budget < 0) {
|
||||
fallbackSort(s->arr1, s->arr2, ftab, nblock);
|
||||
}
|
||||
|
||||
@@ -178,13 +178,22 @@ typedef struct EState {
|
||||
uint8_t selector [BZ_MAX_SELECTORS];
|
||||
uint8_t selectorMtf[BZ_MAX_SELECTORS];
|
||||
|
||||
uint8_t len [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
|
||||
int32_t code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
|
||||
int32_t rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
|
||||
uint8_t len[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
|
||||
|
||||
/* stack-saving measures: these can be local, but they are too big */
|
||||
int32_t sendMTFValues__code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
|
||||
int32_t sendMTFValues__rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
|
||||
#if CONFIG_BZIP2_FEATURE_SPEED >= 5
|
||||
/* second dimension: only 3 needed; 4 makes index calculations faster */
|
||||
uint32_t len_pack[BZ_MAX_ALPHA_SIZE][4];
|
||||
uint32_t sendMTFValues__len_pack[BZ_MAX_ALPHA_SIZE][4];
|
||||
#endif
|
||||
int32_t BZ2_hbMakeCodeLengths__heap [BZ_MAX_ALPHA_SIZE + 2];
|
||||
int32_t BZ2_hbMakeCodeLengths__weight[BZ_MAX_ALPHA_SIZE * 2];
|
||||
int32_t BZ2_hbMakeCodeLengths__parent[BZ_MAX_ALPHA_SIZE * 2];
|
||||
|
||||
int32_t mainSort__runningOrder[256];
|
||||
int32_t mainSort__copyStart[256];
|
||||
int32_t mainSort__copyEnd[256];
|
||||
} EState;
|
||||
|
||||
|
||||
@@ -203,7 +212,7 @@ static void
|
||||
BZ2_hbAssignCodes(int32_t*, uint8_t*, int32_t, int32_t, int32_t);
|
||||
|
||||
static void
|
||||
BZ2_hbMakeCodeLengths(uint8_t*, int32_t*, int32_t, int32_t);
|
||||
BZ2_hbMakeCodeLengths(EState*, uint8_t*, int32_t*, int32_t, int32_t);
|
||||
|
||||
/*-------------------------------------------------------------*/
|
||||
/*--- end bzlib_private.h ---*/
|
||||
|
||||
@@ -264,13 +264,16 @@ void sendMTFValues(EState* s)
|
||||
* are also globals only used in this proc.
|
||||
* Made global to keep stack frame size small.
|
||||
*/
|
||||
#define code sendMTFValues__code
|
||||
#define rfreq sendMTFValues__rfreq
|
||||
#define len_pack sendMTFValues__len_pack
|
||||
|
||||
uint16_t cost[BZ_N_GROUPS];
|
||||
int32_t fave[BZ_N_GROUPS];
|
||||
|
||||
uint16_t* mtfv = s->mtfv;
|
||||
|
||||
alphaSize = s->nInUse+2;
|
||||
alphaSize = s->nInUse + 2;
|
||||
for (t = 0; t < BZ_N_GROUPS; t++)
|
||||
for (v = 0; v < alphaSize; v++)
|
||||
s->len[t][v] = BZ_GREATER_ICOST;
|
||||
@@ -453,7 +456,7 @@ void sendMTFValues(EState* s)
|
||||
/* maxLen was changed from 20 to 17 in bzip2-1.0.3. See
|
||||
* comment in huffman.c for details. */
|
||||
for (t = 0; t < nGroups; t++)
|
||||
BZ2_hbMakeCodeLengths(&(s->len[t][0]), &(s->rfreq[t][0]), alphaSize, 17 /*20*/);
|
||||
BZ2_hbMakeCodeLengths(s, &(s->len[t][0]), &(s->rfreq[t][0]), alphaSize, 17 /*20*/);
|
||||
}
|
||||
|
||||
AssertH(nGroups < 8, 3002);
|
||||
@@ -602,6 +605,9 @@ void sendMTFValues(EState* s)
|
||||
selCtr++;
|
||||
}
|
||||
AssertH(selCtr == nSelectors, 3007);
|
||||
#undef code
|
||||
#undef rfreq
|
||||
#undef len_pack
|
||||
}
|
||||
|
||||
|
||||
|
||||
+10
-1
@@ -98,7 +98,8 @@ void DOWNHEAP1(int32_t *heap, int32_t *weight, int32_t nHeap)
|
||||
|
||||
/*---------------------------------------------------*/
|
||||
static
|
||||
void BZ2_hbMakeCodeLengths(uint8_t *len,
|
||||
void BZ2_hbMakeCodeLengths(EState *s,
|
||||
uint8_t *len,
|
||||
int32_t *freq,
|
||||
int32_t alphaSize,
|
||||
int32_t maxLen)
|
||||
@@ -110,9 +111,14 @@ void BZ2_hbMakeCodeLengths(uint8_t *len,
|
||||
int32_t nNodes, nHeap, n1, n2, i, j, k;
|
||||
Bool tooLong;
|
||||
|
||||
/* bbox: moved to EState to save stack
|
||||
int32_t heap [BZ_MAX_ALPHA_SIZE + 2];
|
||||
int32_t weight[BZ_MAX_ALPHA_SIZE * 2];
|
||||
int32_t parent[BZ_MAX_ALPHA_SIZE * 2];
|
||||
*/
|
||||
#define heap (s->BZ2_hbMakeCodeLengths__heap)
|
||||
#define weight (s->BZ2_hbMakeCodeLengths__weight)
|
||||
#define parent (s->BZ2_hbMakeCodeLengths__parent)
|
||||
|
||||
for (i = 0; i < alphaSize; i++)
|
||||
weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
|
||||
@@ -189,6 +195,9 @@ void BZ2_hbMakeCodeLengths(uint8_t *len,
|
||||
weight[i] = j << 8;
|
||||
}
|
||||
}
|
||||
#undef heap
|
||||
#undef weight
|
||||
#undef parent
|
||||
}
|
||||
|
||||
|
||||
|
||||
+1
-1
@@ -141,7 +141,7 @@ char* make_new_name_bzip2(char *filename)
|
||||
}
|
||||
|
||||
int bzip2_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int bzip2_main(int argc, char **argv)
|
||||
int bzip2_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
unsigned opt;
|
||||
|
||||
|
||||
+9
-13
@@ -602,7 +602,7 @@ static unsigned fill_package_struct(char *control_buffer)
|
||||
&field_name, &field_value);
|
||||
|
||||
if (field_name == NULL) {
|
||||
goto fill_package_struct_cleanup; /* Oh no, the dreaded goto statement! */
|
||||
goto fill_package_struct_cleanup;
|
||||
}
|
||||
|
||||
field_num = index_in_strings(field_names, field_name);
|
||||
@@ -745,7 +745,7 @@ static void index_status_file(const char *filename)
|
||||
unsigned status_num;
|
||||
|
||||
status_file = xfopen(filename, "r");
|
||||
while ((control_buffer = xmalloc_fgets_str(status_file, "\n\n")) != NULL) {
|
||||
while ((control_buffer = xmalloc_fgetline_str(status_file, "\n\n")) != NULL) {
|
||||
const unsigned package_num = fill_package_struct(control_buffer);
|
||||
if (package_num != -1) {
|
||||
status_node = xmalloc(sizeof(status_node_t));
|
||||
@@ -798,7 +798,7 @@ static void write_status_file(deb_file_t **deb_file)
|
||||
int i = 0;
|
||||
|
||||
/* Update previously known packages */
|
||||
while ((control_buffer = xmalloc_fgets_str(old_status_file, "\n\n")) != NULL) {
|
||||
while ((control_buffer = xmalloc_fgetline_str(old_status_file, "\n\n")) != NULL) {
|
||||
tmp_string = strstr(control_buffer, "Package:");
|
||||
if (tmp_string == NULL) {
|
||||
continue;
|
||||
@@ -913,20 +913,16 @@ static void write_status_file(deb_file_t **deb_file)
|
||||
fclose(old_status_file);
|
||||
fclose(new_status_file);
|
||||
|
||||
|
||||
/* Create a separate backfile to dpkg */
|
||||
if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
|
||||
struct stat stat_buf;
|
||||
xstat("/var/lib/dpkg/status", &stat_buf);
|
||||
if (errno != ENOENT)
|
||||
bb_error_msg_and_die("cannot create backup status file");
|
||||
/* Its ok if renaming the status file fails because status
|
||||
* file doesnt exist, maybe we are starting from scratch */
|
||||
bb_error_msg("no status file found, creating new one");
|
||||
}
|
||||
|
||||
if (rename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status") == -1) {
|
||||
bb_error_msg_and_die("DANGER: cannot create status file, "
|
||||
"you need to manually repair your status file");
|
||||
}
|
||||
xrename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status");
|
||||
}
|
||||
|
||||
/* This function returns TRUE if the given package can satisfy a
|
||||
@@ -953,7 +949,7 @@ static int package_satisfies_dependency(int package, int depend_type)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
|
||||
static int check_deps(deb_file_t **deb_file, int deb_start /*, int dep_max_count - ?? */)
|
||||
{
|
||||
int *conflicts = NULL;
|
||||
int conflicts_num = 0;
|
||||
@@ -1344,7 +1340,7 @@ static void remove_package(const unsigned package_num, int noisy)
|
||||
free_array(exclude_files);
|
||||
|
||||
/* rename <package>.conffile to <package>.list */
|
||||
rename(conffile_name, list_name);
|
||||
xrename(conffile_name, list_name);
|
||||
|
||||
/* Change package status */
|
||||
set_status(status_num, "config-files", 3);
|
||||
@@ -1693,7 +1689,7 @@ int dpkg_main(int argc, char **argv)
|
||||
|
||||
/* Check that the deb file arguments are installable */
|
||||
if (!(opt & OPT_force_ignore_depends)) {
|
||||
if (!check_deps(deb_file, 0, deb_count)) {
|
||||
if (!check_deps(deb_file, 0 /*, deb_count*/)) {
|
||||
bb_error_msg_and_die("dependency check failed");
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -41,7 +41,7 @@ int dpkg_deb_main(int argc, char **argv)
|
||||
llist_add_to(&control_tar_llist, (char*)"control.tar.bz2");
|
||||
#endif
|
||||
|
||||
opt_complementary = "?c--efXx:e--cfXx:f--ceXx:X--cefx:x--cefX";
|
||||
opt_complementary = "c--efXx:e--cfXx:f--ceXx:X--cefx:x--cefX";
|
||||
opt = getopt32(argv, "cefXx");
|
||||
|
||||
if (opt & DPKG_DEB_OPT_CONTENTS) {
|
||||
|
||||
+6
-2
@@ -2026,7 +2026,11 @@ USE_DESKTOP(long long) int pack_gzip(void)
|
||||
}
|
||||
|
||||
int gzip_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
#if ENABLE_GUNZIP
|
||||
int gzip_main(int argc, char **argv)
|
||||
#else
|
||||
int gzip_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
#endif
|
||||
{
|
||||
unsigned opt;
|
||||
|
||||
@@ -2042,8 +2046,8 @@ int gzip_main(int argc, char **argv)
|
||||
//if (opt & 0x4) // -v
|
||||
argv += optind;
|
||||
|
||||
PTR_TO_GLOBALS = xzalloc(sizeof(struct globals) + sizeof(struct globals2))
|
||||
+ sizeof(struct globals);
|
||||
SET_PTR_TO_GLOBALS(xzalloc(sizeof(struct globals) + sizeof(struct globals2))
|
||||
+ sizeof(struct globals));
|
||||
G2.l_desc.dyn_tree = G2.dyn_ltree;
|
||||
G2.l_desc.static_tree = G2.static_ltree;
|
||||
G2.l_desc.extra_bits = extra_lbits;
|
||||
|
||||
@@ -3,14 +3,12 @@
|
||||
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
|
||||
*/
|
||||
|
||||
//#include <sys/types.h>
|
||||
|
||||
#include "libbb.h"
|
||||
#include "unarchive.h"
|
||||
|
||||
void data_align(archive_handle_t *archive_handle, const unsigned short boundary)
|
||||
void data_align(archive_handle_t *archive_handle, unsigned boundary)
|
||||
{
|
||||
const unsigned short skip_amount = (boundary - (archive_handle->offset % boundary)) % boundary;
|
||||
unsigned skip_amount = (boundary - (archive_handle->offset % boundary)) % boundary;
|
||||
|
||||
archive_handle->seek(archive_handle, skip_amount);
|
||||
archive_handle->offset += skip_amount;
|
||||
|
||||
@@ -112,7 +112,22 @@ void data_extract_all(archive_handle_t *archive_handle)
|
||||
}
|
||||
|
||||
if (!(archive_handle->flags & ARCHIVE_NOPRESERVE_OWN)) {
|
||||
#if ENABLE_FEATURE_TAR_UNAME_GNAME
|
||||
uid_t uid = file_header->uid;
|
||||
gid_t gid = file_header->gid;
|
||||
|
||||
if (file_header->uname) {
|
||||
struct passwd *pwd = getpwnam(file_header->uname);
|
||||
if (pwd) uid = pwd->pw_uid;
|
||||
}
|
||||
if (file_header->gname) {
|
||||
struct group *grp = getgrnam(file_header->gname);
|
||||
if (grp) gid = grp->gr_gid;
|
||||
}
|
||||
lchown(file_header->name, uid, gid);
|
||||
#else
|
||||
lchown(file_header->name, file_header->uid, file_header->gid);
|
||||
#endif
|
||||
}
|
||||
if ((file_header->mode & S_IFMT) != S_IFLNK) {
|
||||
/* uclibc has no lchmod, glibc is even stranger -
|
||||
|
||||
@@ -282,14 +282,16 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
while (global_pos + buffer_pos < header.dst_size) {
|
||||
int pos_state = (buffer_pos + global_pos) & pos_state_mask;
|
||||
|
||||
prob =
|
||||
p + LZMA_IS_MATCH + (state << LZMA_NUM_POS_BITS_MAX) + pos_state;
|
||||
prob = p + LZMA_IS_MATCH + (state << LZMA_NUM_POS_BITS_MAX) + pos_state;
|
||||
if (rc_is_bit_0(rc, prob)) {
|
||||
mi = 1;
|
||||
rc_update_bit_0(rc, prob);
|
||||
prob = (p + LZMA_LITERAL + (LZMA_LIT_SIZE
|
||||
* ((((buffer_pos + global_pos) & literal_pos_mask) << lc)
|
||||
+ (previous_byte >> (8 - lc)))));
|
||||
prob = (p + LZMA_LITERAL
|
||||
+ (LZMA_LIT_SIZE * ((((buffer_pos + global_pos) & literal_pos_mask) << lc)
|
||||
+ (previous_byte >> (8 - lc))
|
||||
)
|
||||
)
|
||||
);
|
||||
|
||||
if (state >= LZMA_NUM_LIT_STATES) {
|
||||
int match_byte;
|
||||
@@ -304,21 +306,25 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
match_byte <<= 1;
|
||||
bit = match_byte & 0x100;
|
||||
prob_lit = prob + 0x100 + bit + mi;
|
||||
if (rc_get_bit(rc, prob_lit, &mi)) {
|
||||
if (!bit)
|
||||
break;
|
||||
} else {
|
||||
if (bit)
|
||||
break;
|
||||
}
|
||||
bit ^= (rc_get_bit(rc, prob_lit, &mi) << 8); /* 0x100 or 0 */
|
||||
if (bit)
|
||||
break;
|
||||
} while (mi < 0x100);
|
||||
}
|
||||
while (mi < 0x100) {
|
||||
prob_lit = prob + mi;
|
||||
rc_get_bit(rc, prob_lit, &mi);
|
||||
}
|
||||
previous_byte = (uint8_t) mi;
|
||||
|
||||
state -= 3;
|
||||
if (state < 4-3)
|
||||
state = 0;
|
||||
if (state >= 10-3)
|
||||
state -= 6-3;
|
||||
|
||||
previous_byte = (uint8_t) mi;
|
||||
#if ENABLE_FEATURE_LZMA_FAST
|
||||
one_byte1:
|
||||
buffer[buffer_pos++] = previous_byte;
|
||||
if (buffer_pos == header.dict_size) {
|
||||
buffer_pos = 0;
|
||||
@@ -327,12 +333,10 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
goto bad;
|
||||
USE_DESKTOP(total_written += header.dict_size;)
|
||||
}
|
||||
if (state < 4)
|
||||
state = 0;
|
||||
else if (state < 10)
|
||||
state -= 3;
|
||||
else
|
||||
state -= 6;
|
||||
#else
|
||||
len = 1;
|
||||
goto one_byte2;
|
||||
#endif
|
||||
} else {
|
||||
int offset;
|
||||
uint16_t *prob_len;
|
||||
@@ -352,24 +356,23 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
if (rc_is_bit_0(rc, prob)) {
|
||||
rc_update_bit_0(rc, prob);
|
||||
prob = (p + LZMA_IS_REP_0_LONG
|
||||
+ (state << LZMA_NUM_POS_BITS_MAX) + pos_state);
|
||||
+ (state << LZMA_NUM_POS_BITS_MAX)
|
||||
+ pos_state
|
||||
);
|
||||
if (rc_is_bit_0(rc, prob)) {
|
||||
rc_update_bit_0(rc, prob);
|
||||
|
||||
state = state < LZMA_NUM_LIT_STATES ? 9 : 11;
|
||||
#if ENABLE_FEATURE_LZMA_FAST
|
||||
pos = buffer_pos - rep0;
|
||||
while (pos >= header.dict_size)
|
||||
pos += header.dict_size;
|
||||
previous_byte = buffer[pos];
|
||||
buffer[buffer_pos++] = previous_byte;
|
||||
if (buffer_pos == header.dict_size) {
|
||||
buffer_pos = 0;
|
||||
global_pos += header.dict_size;
|
||||
if (full_write(dst_fd, buffer, header.dict_size) != header.dict_size)
|
||||
goto bad;
|
||||
USE_DESKTOP(total_written += header.dict_size;)
|
||||
}
|
||||
continue;
|
||||
goto one_byte1;
|
||||
#else
|
||||
len = 1;
|
||||
goto string;
|
||||
#endif
|
||||
} else {
|
||||
rc_update_bit_1(rc, prob);
|
||||
}
|
||||
@@ -405,7 +408,7 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
if (rc_is_bit_0(rc, prob_len)) {
|
||||
rc_update_bit_0(rc, prob_len);
|
||||
prob_len = (prob + LZMA_LEN_LOW
|
||||
+ (pos_state << LZMA_LEN_NUM_LOW_BITS));
|
||||
+ (pos_state << LZMA_LEN_NUM_LOW_BITS));
|
||||
offset = 0;
|
||||
num_bits = LZMA_LEN_NUM_LOW_BITS;
|
||||
} else {
|
||||
@@ -414,14 +417,14 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
if (rc_is_bit_0(rc, prob_len)) {
|
||||
rc_update_bit_0(rc, prob_len);
|
||||
prob_len = (prob + LZMA_LEN_MID
|
||||
+ (pos_state << LZMA_LEN_NUM_MID_BITS));
|
||||
+ (pos_state << LZMA_LEN_NUM_MID_BITS));
|
||||
offset = 1 << LZMA_LEN_NUM_LOW_BITS;
|
||||
num_bits = LZMA_LEN_NUM_MID_BITS;
|
||||
} else {
|
||||
rc_update_bit_1(rc, prob_len);
|
||||
prob_len = prob + LZMA_LEN_HIGH;
|
||||
offset = ((1 << LZMA_LEN_NUM_LOW_BITS)
|
||||
+ (1 << LZMA_LEN_NUM_MID_BITS));
|
||||
+ (1 << LZMA_LEN_NUM_MID_BITS));
|
||||
num_bits = LZMA_LEN_NUM_HIGH_BITS;
|
||||
}
|
||||
}
|
||||
@@ -432,12 +435,10 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
int pos_slot;
|
||||
|
||||
state += LZMA_NUM_LIT_STATES;
|
||||
prob =
|
||||
p + LZMA_POS_SLOT +
|
||||
((len <
|
||||
LZMA_NUM_LEN_TO_POS_STATES ? len :
|
||||
LZMA_NUM_LEN_TO_POS_STATES - 1)
|
||||
<< LZMA_NUM_POS_SLOT_BITS);
|
||||
prob = p + LZMA_POS_SLOT +
|
||||
((len < LZMA_NUM_LEN_TO_POS_STATES ? len :
|
||||
LZMA_NUM_LEN_TO_POS_STATES - 1)
|
||||
<< LZMA_NUM_POS_SLOT_BITS);
|
||||
rc_bit_tree_decode(rc, prob, LZMA_NUM_POS_SLOT_BITS,
|
||||
&pos_slot);
|
||||
if (pos_slot >= LZMA_START_POS_MODEL_INDEX) {
|
||||
@@ -468,12 +469,13 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
}
|
||||
|
||||
len += LZMA_MATCH_MIN_LEN;
|
||||
|
||||
SKIP_FEATURE_LZMA_FAST(string:)
|
||||
do {
|
||||
pos = buffer_pos - rep0;
|
||||
while (pos >= header.dict_size)
|
||||
pos += header.dict_size;
|
||||
previous_byte = buffer[pos];
|
||||
SKIP_FEATURE_LZMA_FAST(one_byte2:)
|
||||
buffer[buffer_pos++] = previous_byte;
|
||||
if (buffer_pos == header.dict_size) {
|
||||
buffer_pos = 0;
|
||||
@@ -487,7 +489,6 @@ unpack_lzma_stream(int src_fd, int dst_fd)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (full_write(dst_fd, buffer, buffer_pos) != buffer_pos) {
|
||||
bad:
|
||||
rc_free(rc);
|
||||
|
||||
@@ -85,7 +85,8 @@ typedef struct state_t {
|
||||
|
||||
/* input (compressed) data */
|
||||
unsigned char *bytebuffer; /* buffer itself */
|
||||
unsigned bytebuffer_max; /* buffer size */
|
||||
off_t to_read; /* compressed bytes to read (unzip only, -1 for gunzip) */
|
||||
// unsigned bytebuffer_max; /* buffer size */
|
||||
unsigned bytebuffer_offset; /* buffer position */
|
||||
unsigned bytebuffer_size; /* how much data is there (size <= max) */
|
||||
|
||||
@@ -126,7 +127,10 @@ typedef struct state_t {
|
||||
#define gunzip_crc_table (S()gunzip_crc_table )
|
||||
#define gunzip_bb (S()gunzip_bb )
|
||||
#define gunzip_bk (S()gunzip_bk )
|
||||
#define bytebuffer_max (S()bytebuffer_max )
|
||||
#define to_read (S()to_read )
|
||||
// #define bytebuffer_max (S()bytebuffer_max )
|
||||
// Both gunzip and unzip can use constant buffer size now (16k):
|
||||
#define bytebuffer_max 0x4000
|
||||
#define bytebuffer (S()bytebuffer )
|
||||
#define bytebuffer_offset (S()bytebuffer_offset )
|
||||
#define bytebuffer_size (S()bytebuffer_size )
|
||||
@@ -251,13 +255,18 @@ static unsigned fill_bitbuffer(STATE_PARAM unsigned bitbuffer, unsigned *current
|
||||
{
|
||||
while (*current < required) {
|
||||
if (bytebuffer_offset >= bytebuffer_size) {
|
||||
unsigned sz = bytebuffer_max - 4;
|
||||
if (to_read >= 0 && to_read < sz) /* unzip only */
|
||||
sz = to_read;
|
||||
/* Leave the first 4 bytes empty so we can always unwind the bitbuffer
|
||||
* to the front of the bytebuffer */
|
||||
bytebuffer_size = safe_read(gunzip_src_fd, &bytebuffer[4], bytebuffer_max - 4);
|
||||
bytebuffer_size = safe_read(gunzip_src_fd, &bytebuffer[4], sz);
|
||||
if ((int)bytebuffer_size < 1) {
|
||||
error_msg = "unexpected end of file";
|
||||
abort_unzip(PASS_STATE_ONLY);
|
||||
}
|
||||
if (to_read >= 0) /* unzip only */
|
||||
to_read -= bytebuffer_size;
|
||||
bytebuffer_size += 4;
|
||||
bytebuffer_offset = 4;
|
||||
}
|
||||
@@ -1025,14 +1034,15 @@ inflate_unzip_internal(STATE_PARAM int in, int out)
|
||||
/* For unzip */
|
||||
|
||||
USE_DESKTOP(long long) int
|
||||
inflate_unzip(inflate_unzip_result *res, unsigned bufsize, int in, int out)
|
||||
inflate_unzip(inflate_unzip_result *res, off_t compr_size, int in, int out)
|
||||
{
|
||||
USE_DESKTOP(long long) int n;
|
||||
DECLARE_STATE;
|
||||
|
||||
ALLOC_STATE;
|
||||
|
||||
bytebuffer_max = bufsize + 4;
|
||||
to_read = compr_size;
|
||||
// bytebuffer_max = 0x8000;
|
||||
bytebuffer_offset = 4;
|
||||
bytebuffer = xmalloc(bytebuffer_max);
|
||||
n = inflate_unzip_internal(PASS_STATE in, out);
|
||||
@@ -1176,8 +1186,10 @@ unpack_gz_stream(int in, int out)
|
||||
n = 0;
|
||||
|
||||
ALLOC_STATE;
|
||||
bytebuffer_max = 0x8000;
|
||||
to_read = -1;
|
||||
// bytebuffer_max = 0x8000;
|
||||
bytebuffer = xmalloc(bytebuffer_max);
|
||||
gunzip_src_fd = in;
|
||||
|
||||
again:
|
||||
if (!check_header_gzip(PASS_STATE_ONLY)) {
|
||||
|
||||
@@ -13,11 +13,14 @@
|
||||
*/
|
||||
char filter_accept_reject_list(archive_handle_t *archive_handle)
|
||||
{
|
||||
const char *key = archive_handle->file_header->name;
|
||||
const llist_t *reject_entry = find_list_entry2(archive_handle->reject, key);
|
||||
const char *key;
|
||||
const llist_t *reject_entry;
|
||||
const llist_t *accept_entry;
|
||||
|
||||
key = archive_handle->file_header->name;
|
||||
|
||||
/* If the key is in a reject list fail */
|
||||
reject_entry = find_list_entry2(archive_handle->reject, key);
|
||||
if (reject_entry) {
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
@@ -38,7 +38,7 @@ const llist_t *find_list_entry2(const llist_t *list, const char *filename)
|
||||
if (*c++ == '/') pattern_slash_cnt++;
|
||||
c = filename;
|
||||
d = buf;
|
||||
/* paranoia is better that buffer overflows */
|
||||
/* paranoia is better than buffer overflows */
|
||||
while (*c && d != buf + sizeof(buf)-1) {
|
||||
if (*c == '/' && --pattern_slash_cnt < 0)
|
||||
break;
|
||||
|
||||
@@ -46,6 +46,9 @@ void BUG_tar_header_size(void);
|
||||
char get_header_tar(archive_handle_t *archive_handle)
|
||||
{
|
||||
static smallint end;
|
||||
#if ENABLE_FEATURE_TAR_AUTODETECT
|
||||
static smallint not_first;
|
||||
#endif
|
||||
|
||||
file_header_t *file_header = archive_handle->file_header;
|
||||
struct {
|
||||
@@ -59,8 +62,12 @@ char get_header_tar(archive_handle_t *archive_handle)
|
||||
char chksum[8]; /* 148-155 */
|
||||
char typeflag; /* 156-156 */
|
||||
char linkname[100]; /* 157-256 */
|
||||
char magic[6]; /* 257-262 */
|
||||
char version[2]; /* 263-264 */
|
||||
/* POSIX: "ustar" NUL "00" */
|
||||
/* GNU tar: "ustar " NUL */
|
||||
/* Normally it's defined as magic[6] followed by
|
||||
* version[2], but we put them together to save code.
|
||||
*/
|
||||
char magic[8]; /* 257-264 */
|
||||
char uname[32]; /* 265-296 */
|
||||
char gname[32]; /* 297-328 */
|
||||
char devmajor[8]; /* 329-336 */
|
||||
@@ -86,17 +93,32 @@ char get_header_tar(archive_handle_t *archive_handle)
|
||||
|
||||
again_after_align:
|
||||
|
||||
#if ENABLE_DESKTOP
|
||||
i = full_read(archive_handle->src_fd, &tar, 512);
|
||||
/* if GNU tar sees EOF in above read, it says:
|
||||
* "tar: A lone zero block at N", where N = kilobyte
|
||||
* where EOF was met (not EOF block, actual EOF!),
|
||||
* and tar will exit with error code 0.
|
||||
* We will mimic exit(EXIT_SUCCESS), although we will not mimic
|
||||
* the message and we don't check whether we indeed
|
||||
* saw zero block directly before this. */
|
||||
if (i == 0)
|
||||
xfunc_error_retval = 0;
|
||||
if (i != 512)
|
||||
bb_error_msg_and_die("short read");
|
||||
#else
|
||||
xread(archive_handle->src_fd, &tar, 512);
|
||||
#endif
|
||||
archive_handle->offset += 512;
|
||||
|
||||
/* If there is no filename its an empty header */
|
||||
if (tar.name[0] == 0) {
|
||||
if (tar.name[0] == 0 && tar.prefix[0] == 0) {
|
||||
if (end) {
|
||||
/* This is the second consecutive empty header! End of archive!
|
||||
* Read until the end to empty the pipe from gz or bz2
|
||||
*/
|
||||
while (full_read(archive_handle->src_fd, &tar, 512) == 512)
|
||||
/* repeat */;
|
||||
continue;
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
end = 1;
|
||||
@@ -104,16 +126,49 @@ char get_header_tar(archive_handle_t *archive_handle)
|
||||
}
|
||||
end = 0;
|
||||
|
||||
/* Check header has valid magic, "ustar" is for the proper tar
|
||||
* 0's are for the old tar format
|
||||
*/
|
||||
if (strncmp(tar.magic, "ustar", 5) != 0) {
|
||||
#if ENABLE_FEATURE_TAR_OLDGNU_COMPATIBILITY
|
||||
if (memcmp(tar.magic, "\0\0\0\0", 5) != 0)
|
||||
/* Check header has valid magic, "ustar" is for the proper tar,
|
||||
* five NULs are for the old tar format */
|
||||
if (strncmp(tar.magic, "ustar", 5) != 0
|
||||
&& (!ENABLE_FEATURE_TAR_OLDGNU_COMPATIBILITY
|
||||
|| memcmp(tar.magic, "\0\0\0\0", 5) != 0)
|
||||
) {
|
||||
#if ENABLE_FEATURE_TAR_AUTODETECT
|
||||
char (*get_header_ptr)(archive_handle_t *);
|
||||
|
||||
/* tar gz/bz autodetect: check for gz/bz2 magic.
|
||||
* If it is the very first block, and we see the magic,
|
||||
* we can switch to get_header_tar_gz/bz2/lzma().
|
||||
* Needs seekable fd. I wish recv(MSG_PEEK) works
|
||||
* on any fd... */
|
||||
if (not_first)
|
||||
goto err;
|
||||
#if ENABLE_FEATURE_TAR_GZIP
|
||||
if (tar.name[0] == 0x1f && tar.name[1] == (char)0x8b) { /* gzip */
|
||||
get_header_ptr = get_header_tar_gz;
|
||||
} else
|
||||
#endif
|
||||
bb_error_msg_and_die("invalid tar magic");
|
||||
#if ENABLE_FEATURE_TAR_BZIP2
|
||||
if (tar.name[0] == 'B' && tar.name[1] == 'Z'
|
||||
&& tar.name[2] == 'h' && isdigit(tar.name[3])
|
||||
) { /* bzip2 */
|
||||
get_header_ptr = get_header_tar_bz2;
|
||||
} else
|
||||
#endif
|
||||
goto err;
|
||||
if (lseek(archive_handle->src_fd, -512, SEEK_CUR) != 0)
|
||||
goto err;
|
||||
while (get_header_ptr(archive_handle) == EXIT_SUCCESS)
|
||||
continue;
|
||||
return EXIT_FAILURE;
|
||||
err:
|
||||
#endif /* FEATURE_TAR_AUTODETECT */
|
||||
bb_error_msg_and_die("invalid tar magic");
|
||||
}
|
||||
|
||||
#if ENABLE_FEATURE_TAR_AUTODETECT
|
||||
not_first = 1;
|
||||
#endif
|
||||
|
||||
/* Do checksum on headers.
|
||||
* POSIX says that checksum is done on unsigned bytes, but
|
||||
* Sun and HP-UX gets it wrong... more details in
|
||||
@@ -156,18 +211,23 @@ char get_header_tar(archive_handle_t *archive_handle)
|
||||
/* getOctal trashes subsequent field, therefore we call it
|
||||
* on fields in reverse order */
|
||||
if (tar.devmajor[0]) {
|
||||
char t = tar.prefix[0];
|
||||
/* we trash prefix[0] here, but we DO need it later! */
|
||||
unsigned minor = GET_OCTAL(tar.devminor);
|
||||
unsigned major = GET_OCTAL(tar.devmajor);
|
||||
file_header->device = makedev(major, minor);
|
||||
tar.prefix[0] = t;
|
||||
}
|
||||
file_header->link_target = NULL;
|
||||
if (!linkname && parse_names && tar.linkname[0]) {
|
||||
/* we trash magic[0] here, it's ok */
|
||||
tar.linkname[sizeof(tar.linkname)] = '\0';
|
||||
file_header->link_target = xstrdup(tar.linkname);
|
||||
file_header->link_target = xstrndup(tar.linkname, sizeof(tar.linkname));
|
||||
/* FIXME: what if we have non-link object with link_target? */
|
||||
/* Will link_target be free()ed? */
|
||||
}
|
||||
#if ENABLE_FEATURE_TAR_UNAME_GNAME
|
||||
file_header->uname = tar.uname[0] ? xstrndup(tar.uname, sizeof(tar.uname)) : NULL;
|
||||
file_header->gname = tar.gname[0] ? xstrndup(tar.gname, sizeof(tar.gname)) : NULL;
|
||||
#endif
|
||||
file_header->mtime = GET_OCTAL(tar.mtime);
|
||||
file_header->size = GET_OCTAL(tar.size);
|
||||
file_header->gid = GET_OCTAL(tar.gid);
|
||||
@@ -178,10 +238,12 @@ char get_header_tar(archive_handle_t *archive_handle)
|
||||
file_header->name = NULL;
|
||||
if (!longname && parse_names) {
|
||||
/* we trash mode[0] here, it's ok */
|
||||
tar.name[sizeof(tar.name)] = '\0';
|
||||
//tar.name[sizeof(tar.name)] = '\0'; - gcc 4.3.0 would complain
|
||||
tar.mode[0] = '\0';
|
||||
if (tar.prefix[0]) {
|
||||
/* and padding[0] */
|
||||
tar.prefix[sizeof(tar.prefix)] = '\0';
|
||||
//tar.prefix[sizeof(tar.prefix)] = '\0'; - gcc 4.3.0 would complain
|
||||
tar.padding[0] = '\0';
|
||||
file_header->name = concat_path_file(tar.prefix, tar.name);
|
||||
} else
|
||||
file_header->name = xstrdup(tar.name);
|
||||
@@ -298,6 +360,9 @@ char get_header_tar(archive_handle_t *archive_handle)
|
||||
|
||||
free(file_header->link_target);
|
||||
/* Do not free(file_header->name)! */
|
||||
|
||||
#if ENABLE_FEATURE_TAR_UNAME_GNAME
|
||||
free(file_header->uname);
|
||||
free(file_header->gname);
|
||||
#endif
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
@@ -11,7 +11,7 @@ char get_header_tar_bz2(archive_handle_t *archive_handle)
|
||||
/* Can't lseek over pipes */
|
||||
archive_handle->seek = seek_by_read;
|
||||
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, unpack_bz2_stream, "bunzip2", "bunzip2", "-cf", "-", NULL);
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, unpack_bz2_stream, "bunzip2");
|
||||
archive_handle->offset = 0;
|
||||
while (get_header_tar(archive_handle) == EXIT_SUCCESS)
|
||||
continue;
|
||||
|
||||
@@ -25,7 +25,7 @@ char get_header_tar_gz(archive_handle_t *archive_handle)
|
||||
}
|
||||
#endif
|
||||
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, unpack_gz_stream, "gunzip", "gunzip", "-cf", "-", NULL);
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, unpack_gz_stream, "gunzip");
|
||||
archive_handle->offset = 0;
|
||||
while (get_header_tar(archive_handle) == EXIT_SUCCESS)
|
||||
continue;
|
||||
|
||||
@@ -14,7 +14,7 @@ char get_header_tar_lzma(archive_handle_t * archive_handle)
|
||||
/* Can't lseek over pipes */
|
||||
archive_handle->seek = seek_by_read;
|
||||
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, unpack_lzma_stream, "unlzma", "unlzma", "-cf", "-", NULL);
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, unpack_lzma_stream, "unlzma");
|
||||
archive_handle->offset = 0;
|
||||
while (get_header_tar(archive_handle) == EXIT_SUCCESS)
|
||||
continue;
|
||||
|
||||
@@ -10,6 +10,33 @@ void header_verbose_list(const file_header_t *file_header)
|
||||
{
|
||||
struct tm *mtime = localtime(&(file_header->mtime));
|
||||
|
||||
#if ENABLE_FEATURE_TAR_UNAME_GNAME
|
||||
char uid[8];
|
||||
char gid[8];
|
||||
char *user = file_header->uname;
|
||||
char *group = file_header->gname;
|
||||
|
||||
if (user == NULL) {
|
||||
snprintf(uid, sizeof(uid), "%u", (unsigned)file_header->uid);
|
||||
user = uid;
|
||||
}
|
||||
if (group == NULL) {
|
||||
snprintf(gid, sizeof(gid), "%u", (unsigned)file_header->gid);
|
||||
group = gid;
|
||||
}
|
||||
printf("%s %s/%s %9u %4u-%02u-%02u %02u:%02u:%02u %s",
|
||||
bb_mode_string(file_header->mode),
|
||||
user,
|
||||
group,
|
||||
(unsigned int) file_header->size,
|
||||
1900 + mtime->tm_year,
|
||||
1 + mtime->tm_mon,
|
||||
mtime->tm_mday,
|
||||
mtime->tm_hour,
|
||||
mtime->tm_min,
|
||||
mtime->tm_sec,
|
||||
file_header->name);
|
||||
#else /* !FEATURE_TAR_UNAME_GNAME */
|
||||
printf("%s %d/%d %9"OFF_FMT"u %4u-%02u-%02u %02u:%02u:%02u %s",
|
||||
bb_mode_string(file_header->mode),
|
||||
file_header->uid,
|
||||
@@ -22,6 +49,7 @@ void header_verbose_list(const file_header_t *file_header)
|
||||
mtime->tm_min,
|
||||
mtime->tm_sec,
|
||||
file_header->name);
|
||||
#endif /* FEATURE_TAR_UNAME_GNAME */
|
||||
|
||||
if (file_header->link_target) {
|
||||
printf(" -> %s", file_header->link_target);
|
||||
|
||||
@@ -8,17 +8,17 @@
|
||||
|
||||
/* transformer(), more than meets the eye */
|
||||
/*
|
||||
* On MMU machine, the transform_prog and ... are stripped
|
||||
* by a macro in include/unarchive.h. On NOMMU, transformer is stripped.
|
||||
* On MMU machine, the transform_prog is removed by macro magic
|
||||
* in include/unarchive.h. On NOMMU, transformer is removed.
|
||||
*/
|
||||
int open_transformer(int src_fd,
|
||||
USE_DESKTOP(long long) int (*transformer)(int src_fd, int dst_fd),
|
||||
const char *transform_prog, ...)
|
||||
const char *transform_prog)
|
||||
{
|
||||
int fd_pipe[2];
|
||||
struct fd_pair fd_pipe;
|
||||
int pid;
|
||||
|
||||
xpipe(fd_pipe);
|
||||
xpiped_pair(fd_pipe);
|
||||
|
||||
#if BB_MMU
|
||||
pid = fork();
|
||||
@@ -29,32 +29,34 @@ int open_transformer(int src_fd,
|
||||
bb_perror_msg_and_die("fork failed");
|
||||
|
||||
if (pid == 0) {
|
||||
#if !BB_MMU
|
||||
va_list ap;
|
||||
#endif
|
||||
/* child process */
|
||||
close(fd_pipe[0]); /* We don't wan't to read from the parent */
|
||||
close(fd_pipe.rd); /* We don't want to read from the parent */
|
||||
// FIXME: error check?
|
||||
#if BB_MMU
|
||||
transformer(src_fd, fd_pipe[1]);
|
||||
transformer(src_fd, fd_pipe.wr);
|
||||
if (ENABLE_FEATURE_CLEAN_UP) {
|
||||
close(fd_pipe[1]); /* Send EOF */
|
||||
close(fd_pipe.wr); /* Send EOF */
|
||||
close(src_fd);
|
||||
}
|
||||
exit(0);
|
||||
#else
|
||||
xmove_fd(src_fd, 0);
|
||||
xmove_fd(fd_pipe[1], 1);
|
||||
va_start(ap, transform_prog);
|
||||
/* hoping that va_list -> char** on our CPU is working... */
|
||||
BB_EXECVP(transform_prog, (void*)ap);
|
||||
bb_perror_msg_and_die("exec failed");
|
||||
{
|
||||
char *argv[4];
|
||||
xmove_fd(src_fd, 0);
|
||||
xmove_fd(fd_pipe.wr, 1);
|
||||
argv[0] = (char*)transform_prog;
|
||||
argv[1] = (char*)"-cf";
|
||||
argv[2] = (char*)"-";
|
||||
argv[3] = NULL;
|
||||
BB_EXECVP(transform_prog, argv);
|
||||
bb_perror_msg_and_die("exec failed");
|
||||
}
|
||||
#endif
|
||||
/* notreached */
|
||||
}
|
||||
|
||||
/* parent process */
|
||||
close(fd_pipe[1]); /* Don't want to write to the child */
|
||||
close(fd_pipe.wr); /* Don't want to write to the child */
|
||||
|
||||
return fd_pipe[0];
|
||||
return fd_pipe.rd;
|
||||
}
|
||||
@@ -6,7 +6,7 @@
|
||||
#include "libbb.h"
|
||||
#include "unarchive.h"
|
||||
|
||||
void seek_by_jump(const archive_handle_t *archive_handle, const unsigned int amount)
|
||||
void seek_by_jump(const archive_handle_t *archive_handle, unsigned amount)
|
||||
{
|
||||
if (lseek(archive_handle->src_fd, (off_t) amount, SEEK_CUR) == (off_t) -1) {
|
||||
#if ENABLE_FEATURE_UNARCHIVE_TAPE
|
||||
|
||||
@@ -6,10 +6,10 @@
|
||||
#include "libbb.h"
|
||||
#include "unarchive.h"
|
||||
|
||||
/* If we are reading through a pipe(), or from stdin then we can't lseek,
|
||||
/* If we are reading through a pipe, or from stdin then we can't lseek,
|
||||
* we must read and discard the data to skip over it.
|
||||
*/
|
||||
void seek_by_read(const archive_handle_t *archive_handle, const unsigned int jump_size)
|
||||
void seek_by_read(const archive_handle_t *archive_handle, unsigned jump_size)
|
||||
{
|
||||
if (jump_size)
|
||||
bb_copyfd_exact_size(archive_handle->src_fd, -1, jump_size);
|
||||
|
||||
+1
-1
@@ -237,7 +237,7 @@ static void extract_cpio_gz(int fd)
|
||||
}
|
||||
|
||||
xchdir("/"); /* Install RPM's to root */
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, xformer, xformer_prog, xformer_prog, "-cf", "-", NULL);
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, xformer, xformer_prog);
|
||||
archive_handle->offset = 0;
|
||||
while (get_header_cpio(archive_handle) == EXIT_SUCCESS)
|
||||
continue;
|
||||
|
||||
+51
-22
@@ -28,8 +28,22 @@
|
||||
#include "libbb.h"
|
||||
#include "unarchive.h"
|
||||
|
||||
/* FIXME: Stop using this non-standard feature */
|
||||
#ifndef FNM_LEADING_DIR
|
||||
#define FNM_LEADING_DIR 0
|
||||
#endif
|
||||
|
||||
|
||||
#define block_buf bb_common_bufsiz1
|
||||
|
||||
|
||||
#if !ENABLE_FEATURE_TAR_GZIP && !ENABLE_FEATURE_TAR_BZIP2
|
||||
/* Do not pass gzip flag to writeTarFile() */
|
||||
#define writeTarFile(tar_fd, verboseFlag, dereferenceFlag, include, exclude, gzip) \
|
||||
writeTarFile(tar_fd, verboseFlag, dereferenceFlag, include, exclude)
|
||||
#endif
|
||||
|
||||
|
||||
#if ENABLE_FEATURE_TAR_CREATE
|
||||
|
||||
/* Tar file constants */
|
||||
@@ -50,14 +64,18 @@ struct TarHeader { /* byte offset */
|
||||
char chksum[8]; /* 148-155 */
|
||||
char typeflag; /* 156-156 */
|
||||
char linkname[NAME_SIZE]; /* 157-256 */
|
||||
char magic[6]; /* 257-262 */
|
||||
char version[2]; /* 263-264 */
|
||||
/* POSIX: "ustar" NUL "00" */
|
||||
/* GNU tar: "ustar " NUL */
|
||||
/* Normally it's defined as magic[6] followed by
|
||||
* version[2], but we put them together to save code.
|
||||
*/
|
||||
char magic[8]; /* 257-264 */
|
||||
char uname[32]; /* 265-296 */
|
||||
char gname[32]; /* 297-328 */
|
||||
char devmajor[8]; /* 329-336 */
|
||||
char devminor[8]; /* 337-344 */
|
||||
char prefix[155]; /* 345-499 */
|
||||
char padding[12]; /* 500-512 (pad to exactly the TAR_BLOCK_SIZE) */
|
||||
char padding[12]; /* 500-512 (pad to exactly TAR_BLOCK_SIZE) */
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -505,21 +523,26 @@ static int writeTarFile(const int tar_fd, const int verboseFlag,
|
||||
if (fstat(tbInfo.tarFd, &tbInfo.statBuf) < 0)
|
||||
bb_perror_msg_and_die("cannot stat tar file");
|
||||
|
||||
if ((ENABLE_FEATURE_TAR_GZIP || ENABLE_FEATURE_TAR_BZIP2) && gzip) {
|
||||
// On Linux, vfork never unpauses parent early, although standard
|
||||
// allows for that. Do we want to waste bytes checking for it?
|
||||
#if ENABLE_FEATURE_TAR_GZIP || ENABLE_FEATURE_TAR_BZIP2
|
||||
if (gzip) {
|
||||
#if ENABLE_FEATURE_TAR_GZIP && ENABLE_FEATURE_TAR_BZIP2
|
||||
const char *zip_exec = (gzip == 1) ? "gzip" : "bzip2";
|
||||
#elif ENABLE_FEATURE_TAR_GZIP
|
||||
const char *zip_exec = "gzip";
|
||||
#else /* only ENABLE_FEATURE_TAR_BZIP2 */
|
||||
const char *zip_exec = "bzip2";
|
||||
#endif
|
||||
// On Linux, vfork never unpauses parent early, although standard
|
||||
// allows for that. Do we want to waste bytes checking for it?
|
||||
#define WAIT_FOR_CHILD 0
|
||||
|
||||
volatile int vfork_exec_errno = 0;
|
||||
#if WAIT_FOR_CHILD
|
||||
struct { int rd; int wr; } gzipStatusPipe;
|
||||
struct fd_pair gzipStatusPipe;
|
||||
#endif
|
||||
struct { int rd; int wr; } gzipDataPipe;
|
||||
const char *zip_exec = (gzip == 1) ? "gzip" : "bzip2";
|
||||
|
||||
xpipe(&gzipDataPipe.rd);
|
||||
struct fd_pair gzipDataPipe;
|
||||
xpiped_pair(gzipDataPipe);
|
||||
#if WAIT_FOR_CHILD
|
||||
xpipe(&gzipStatusPipe.rd);
|
||||
xpiped_pair(gzipStatusPipe);
|
||||
#endif
|
||||
|
||||
signal(SIGPIPE, SIG_IGN); /* we only want EPIPE on errors */
|
||||
@@ -537,13 +560,16 @@ static int writeTarFile(const int tar_fd, const int verboseFlag,
|
||||
|
||||
if (gzipPid == 0) {
|
||||
/* child */
|
||||
xmove_fd(tbInfo.tarFd, 1);
|
||||
xmove_fd(gzipDataPipe.rd, 0);
|
||||
/* NB: close _first_, then move fds! */
|
||||
close(gzipDataPipe.wr);
|
||||
#if WAIT_FOR_CHILD
|
||||
close(gzipStatusPipe.rd);
|
||||
/* gzipStatusPipe.wr will close only on exec -
|
||||
* parent waits for this close to happen */
|
||||
fcntl(gzipStatusPipe.wr, F_SETFD, FD_CLOEXEC);
|
||||
#endif
|
||||
xmove_fd(gzipDataPipe.rd, 0);
|
||||
xmove_fd(tbInfo.tarFd, 1);
|
||||
/* exec gzip/bzip2 program/applet */
|
||||
BB_EXECLP(zip_exec, zip_exec, "-f", NULL);
|
||||
vfork_exec_errno = errno;
|
||||
@@ -561,7 +587,7 @@ static int writeTarFile(const int tar_fd, const int verboseFlag,
|
||||
|
||||
/* Wait until child execs (or fails to) */
|
||||
n = full_read(gzipStatusPipe.rd, &buf, 1);
|
||||
if ((n < 0) && (/*errno == EAGAIN ||*/ errno == EINTR))
|
||||
if (n < 0 /* && errno == EAGAIN */)
|
||||
continue; /* try it again */
|
||||
|
||||
}
|
||||
@@ -572,6 +598,7 @@ static int writeTarFile(const int tar_fd, const int verboseFlag,
|
||||
bb_perror_msg_and_die("cannot exec %s", zip_exec);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
tbInfo.excludeList = exclude;
|
||||
|
||||
@@ -606,7 +633,7 @@ static int writeTarFile(const int tar_fd, const int verboseFlag,
|
||||
|
||||
if (gzipPid) {
|
||||
int status;
|
||||
if (waitpid(gzipPid, &status, 0) == -1)
|
||||
if (safe_waitpid(gzipPid, &status, 0) == -1)
|
||||
bb_perror_msg("waitpid");
|
||||
else if (!WIFEXITED(status) || WEXITSTATUS(status))
|
||||
/* gzip was killed or has exited with nonzero! */
|
||||
@@ -662,7 +689,7 @@ static char get_header_tar_Z(archive_handle_t *archive_handle)
|
||||
bb_error_msg_and_die("invalid magic");
|
||||
}
|
||||
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompress, "uncompress", "uncompress", "-cf", "-", NULL);
|
||||
archive_handle->src_fd = open_transformer(archive_handle->src_fd, uncompress, "uncompress");
|
||||
archive_handle->offset = 0;
|
||||
while (get_header_tar(archive_handle) == EXIT_SUCCESS)
|
||||
continue;
|
||||
@@ -684,7 +711,7 @@ static void handle_SIGCHLD(int status)
|
||||
/* Actually, 'status' is a signo. We reuse it for other needs */
|
||||
|
||||
/* Wait for any child without blocking */
|
||||
if (waitpid(-1, &status, WNOHANG) < 0)
|
||||
if (wait_any_nohang(&status) < 0)
|
||||
/* wait failed?! I'm confused... */
|
||||
return;
|
||||
|
||||
@@ -922,11 +949,13 @@ int tar_main(int argc, char **argv)
|
||||
|
||||
/* create an archive */
|
||||
if (opt & OPT_CREATE) {
|
||||
#if ENABLE_FEATURE_TAR_GZIP || ENABLE_FEATURE_TAR_BZIP2
|
||||
int zipMode = 0;
|
||||
if (ENABLE_FEATURE_TAR_GZIP && get_header_ptr == get_header_tar_gz)
|
||||
if (ENABLE_FEATURE_TAR_GZIP && (opt & OPT_GZIP))
|
||||
zipMode = 1;
|
||||
if (ENABLE_FEATURE_TAR_BZIP2 && get_header_ptr == get_header_tar_bz2)
|
||||
if (ENABLE_FEATURE_TAR_BZIP2 && (opt & OPT_BZIP2))
|
||||
zipMode = 2;
|
||||
#endif
|
||||
/* NB: writeTarFile() closes tar_handle->src_fd */
|
||||
return writeTarFile(tar_handle->src_fd, verboseFlag, opt & OPT_DEREFERENCE,
|
||||
tar_handle->accept,
|
||||
@@ -934,7 +963,7 @@ int tar_main(int argc, char **argv)
|
||||
}
|
||||
|
||||
while (get_header_ptr(tar_handle) == EXIT_SUCCESS)
|
||||
/* nothing */;
|
||||
continue;
|
||||
|
||||
/* Check that every file that should have been extracted was */
|
||||
while (tar_handle->accept) {
|
||||
|
||||
+12
-4
@@ -41,8 +41,10 @@ enum {
|
||||
#endif
|
||||
};
|
||||
|
||||
#define ZIP_HEADER_LEN 26
|
||||
|
||||
typedef union {
|
||||
uint8_t raw[26];
|
||||
uint8_t raw[ZIP_HEADER_LEN];
|
||||
struct {
|
||||
uint16_t version; /* 0-1 */
|
||||
uint16_t flags; /* 2-3 */
|
||||
@@ -55,10 +57,16 @@ typedef union {
|
||||
uint16_t filename_len; /* 22-23 */
|
||||
uint16_t extra_len; /* 24-25 */
|
||||
} formatted ATTRIBUTE_PACKED;
|
||||
} zip_header_t;
|
||||
} zip_header_t; /* ATTRIBUTE_PACKED - gcc 4.2.1 doesn't like it (spews warning) */
|
||||
|
||||
/* Check the offset of the last element, not the length. This leniency
|
||||
* allows for poor packing, whereby the overall struct may be too long,
|
||||
* even though the elements are all in the right place.
|
||||
*/
|
||||
struct BUG_zip_header_must_be_26_bytes {
|
||||
char BUG_zip_header_must_be_26_bytes[sizeof(zip_header_t) == 26 ? 1 : -1];
|
||||
char BUG_zip_header_must_be_26_bytes[
|
||||
offsetof(zip_header_t, formatted.extra_len) + 2 ==
|
||||
ZIP_HEADER_LEN ? 1 : -1];
|
||||
};
|
||||
|
||||
#define FIX_ENDIANNESS(zip_header) do { \
|
||||
@@ -256,7 +264,7 @@ int unzip_main(int argc, char **argv)
|
||||
bb_error_msg_and_die("invalid zip magic %08X", magic);
|
||||
|
||||
/* Read the file header */
|
||||
xread(src_fd, zip_header.raw, sizeof(zip_header));
|
||||
xread(src_fd, zip_header.raw, ZIP_HEADER_LEN);
|
||||
FIX_ENDIANNESS(zip_header);
|
||||
if ((zip_header.formatted.method != 0) && (zip_header.formatted.method != 8)) {
|
||||
bb_error_msg_and_die("unsupported method %d", zip_header.formatted.method);
|
||||
|
||||
@@ -72,7 +72,7 @@ config RESIZE
|
||||
terminal.
|
||||
|
||||
config FEATURE_RESIZE_PRINT
|
||||
bool "print environment variables"
|
||||
bool "Print environment variables"
|
||||
default n
|
||||
depends on RESIZE
|
||||
help
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
#include "libbb.h"
|
||||
|
||||
int clear_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int clear_main(int argc, char **argv)
|
||||
int clear_main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return printf("\033[H\033[J") != 6;
|
||||
}
|
||||
@@ -16,19 +16,15 @@
|
||||
enum { VT_DISALLOCATE = 0x5608 }; /* free memory associated to vt */
|
||||
|
||||
int deallocvt_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int deallocvt_main(int argc, char **argv)
|
||||
int deallocvt_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
/* num = 0 deallocate all unused consoles */
|
||||
int num = 0;
|
||||
|
||||
switch (argc) {
|
||||
case 2:
|
||||
if (argv[1]) {
|
||||
if (argv[2])
|
||||
bb_show_usage();
|
||||
num = xatou_range(argv[1], 1, 63);
|
||||
/* Fallthrough */
|
||||
case 1:
|
||||
break;
|
||||
default:
|
||||
bb_show_usage();
|
||||
}
|
||||
|
||||
/* double cast suppresses "cast to ptr from int of different size" */
|
||||
|
||||
@@ -167,7 +167,7 @@ static void loadnewfont(int fd)
|
||||
}
|
||||
|
||||
int loadfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int loadfont_main(int argc, char **argv)
|
||||
int loadfont_main(int argc, char **argv ATTRIBUTE_UNUSED)
|
||||
{
|
||||
int fd;
|
||||
|
||||
|
||||
@@ -26,7 +26,7 @@ struct kbentry {
|
||||
#define MAX_NR_KEYMAPS 256
|
||||
|
||||
int loadkmap_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int loadkmap_main(int argc, char **argv)
|
||||
int loadkmap_main(int argc, char **argv ATTRIBUTE_UNUSED)
|
||||
{
|
||||
struct kbentry ke;
|
||||
int i, j, fd;
|
||||
|
||||
@@ -27,9 +27,10 @@ int openvt_main(int argc, char **argv)
|
||||
/* grab new one */
|
||||
close(0);
|
||||
xopen(vtname, O_RDWR);
|
||||
dup2(0, STDOUT_FILENO);
|
||||
dup2(0, STDERR_FILENO);
|
||||
xdup2(0, STDOUT_FILENO);
|
||||
xdup2(0, STDERR_FILENO);
|
||||
|
||||
BB_EXECVP(argv[2], &argv[2]);
|
||||
argv += 2;
|
||||
BB_EXECVP(argv[0], argv);
|
||||
_exit(1);
|
||||
}
|
||||
+22
-5
@@ -8,14 +8,25 @@
|
||||
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
|
||||
*/
|
||||
|
||||
/* no options, no getopt */
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
/* BTW, which "standard" package has this utility? It doesn't seem
|
||||
* to be ncurses, coreutils, console-tools... then what? */
|
||||
|
||||
#if ENABLE_STTY
|
||||
int stty_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
#endif
|
||||
|
||||
int reset_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int reset_main(int argc, char **argv)
|
||||
int reset_main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
|
||||
{
|
||||
if (isatty(1)) {
|
||||
static const char *const args[] = {
|
||||
"stty", "sane", NULL
|
||||
};
|
||||
|
||||
/* no options, no getopt */
|
||||
|
||||
if (isatty(0) && isatty(1)) {
|
||||
/* See 'man 4 console_codes' for details:
|
||||
* "ESC c" -- Reset
|
||||
* "ESC ( K" -- Select user mapping
|
||||
@@ -24,7 +35,13 @@ int reset_main(int argc, char **argv)
|
||||
* "ESC [ ? 25 h" -- Make cursor visible.
|
||||
*/
|
||||
printf("\033c\033(K\033[J\033[0m\033[?25h");
|
||||
/* http://bugs.busybox.net/view.php?id=1414:
|
||||
* people want it to reset echo etc: */
|
||||
#if ENABLE_STTY
|
||||
return stty_main(2, (char**)args);
|
||||
#else
|
||||
execvp("stty", (char**)args);
|
||||
#endif
|
||||
}
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -21,10 +21,10 @@ onintr(int sig ATTRIBUTE_UNUSED)
|
||||
}
|
||||
|
||||
int resize_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int resize_main(int argc, char **argv)
|
||||
int resize_main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
|
||||
{
|
||||
struct termios new;
|
||||
struct winsize w = { 0,0,0,0 };
|
||||
struct winsize w = { 0, 0, 0, 0 };
|
||||
int ret;
|
||||
|
||||
/* We use _stderr_ in order to make resize usable
|
||||
@@ -37,10 +37,12 @@ int resize_main(int argc, char **argv)
|
||||
new = old_termios;
|
||||
new.c_cflag |= (CLOCAL | CREAD);
|
||||
new.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
|
||||
signal(SIGINT, onintr);
|
||||
signal(SIGQUIT, onintr);
|
||||
signal(SIGTERM, onintr);
|
||||
signal(SIGALRM, onintr);
|
||||
bb_signals(0
|
||||
+ (1 << SIGINT)
|
||||
+ (1 << SIGQUIT)
|
||||
+ (1 << SIGTERM)
|
||||
+ (1 << SIGALRM)
|
||||
, onintr);
|
||||
tcsetattr(STDERR_FILENO, TCSANOW, &new);
|
||||
|
||||
/* save_cursor_pos 7
|
||||
|
||||
@@ -14,7 +14,7 @@
|
||||
|
||||
/* From <linux/kd.h> */
|
||||
struct kbkeycode {
|
||||
unsigned int scancode, keycode;
|
||||
unsigned scancode, keycode;
|
||||
};
|
||||
enum {
|
||||
KDSETKEYCODE = 0x4B4D /* write kernel keycode table entry */
|
||||
@@ -33,7 +33,7 @@ int setkeycodes_main(int argc, char **argv)
|
||||
fd = get_console_fd();
|
||||
|
||||
while (argc > 2) {
|
||||
a.keycode = xatoul_range(argv[2], 0, 127);
|
||||
a.keycode = xatou_range(argv[2], 0, 127);
|
||||
a.scancode = sc = xstrtoul_range(argv[1], 16, 0, 255);
|
||||
if (a.scancode > 127) {
|
||||
a.scancode -= 0xe000;
|
||||
|
||||
@@ -12,7 +12,7 @@
|
||||
#include "libbb.h"
|
||||
|
||||
int setlogcons_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int setlogcons_main(int argc, char **argv)
|
||||
int setlogcons_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
struct {
|
||||
char fn;
|
||||
@@ -22,8 +22,8 @@ int setlogcons_main(int argc, char **argv)
|
||||
arg.fn = 11; /* redirect kernel messages */
|
||||
arg.subarg = 0; /* to specified console (current as default) */
|
||||
|
||||
if (argc == 2)
|
||||
arg.subarg = xatoul_range(argv[1], 0, 63);
|
||||
if (argv[1])
|
||||
arg.subarg = xatou_range(argv[1], 0, 63);
|
||||
|
||||
xioctl(xopen(VC_1, O_RDONLY), TIOCLINUX, &arg);
|
||||
|
||||
|
||||
+24
-3
@@ -135,6 +135,13 @@ config DF
|
||||
df reports the amount of disk space used and available
|
||||
on filesystems.
|
||||
|
||||
config FEATURE_DF_INODE
|
||||
bool "Enable -i (inode information)"
|
||||
default n
|
||||
depends on DF
|
||||
help
|
||||
This option enables support for df -i.
|
||||
|
||||
config DIRNAME
|
||||
bool "dirname"
|
||||
default n
|
||||
@@ -481,6 +488,14 @@ config RMDIR
|
||||
help
|
||||
rmdir is used to remove empty directories.
|
||||
|
||||
config FEATURE_RMDIR_LONG_OPTIONS
|
||||
bool "Enable long options"
|
||||
default n
|
||||
depends on RMDIR && GETOPT_LONG
|
||||
help
|
||||
Support long options for the rmdir applet, including
|
||||
--ignore-fail-on-non-empty for compatibility with GNU rmdir.
|
||||
|
||||
config SEQ
|
||||
bool "seq"
|
||||
default n
|
||||
@@ -513,7 +528,7 @@ config SORT
|
||||
sort is used to sort lines of text in specified files.
|
||||
|
||||
config FEATURE_SORT_BIG
|
||||
bool "full SuSv3 compliant sort (Support -ktcsbdfiozgM)"
|
||||
bool "Full SuSv3 compliant sort (support -ktcsbdfiozgM)"
|
||||
default y
|
||||
depends on SORT
|
||||
help
|
||||
@@ -531,7 +546,7 @@ config SPLIT
|
||||
split a file into pieces.
|
||||
|
||||
config FEATURE_SPLIT_FANCY
|
||||
bool "fancy extensions"
|
||||
bool "Fancy extensions"
|
||||
default n
|
||||
depends on SPLIT
|
||||
help
|
||||
@@ -572,6 +587,12 @@ config SYNC
|
||||
help
|
||||
sync is used to flush filesystem buffers.
|
||||
|
||||
config TAC
|
||||
bool "tac"
|
||||
default n
|
||||
help
|
||||
tac is used to concatenate and print files in reverse.
|
||||
|
||||
config TAIL
|
||||
bool "tail"
|
||||
default n
|
||||
@@ -595,7 +616,7 @@ config TEE
|
||||
to standard output and files.
|
||||
|
||||
config FEATURE_TEE_USE_BLOCK_IO
|
||||
bool "Enable block i/o (larger/faster) instead of byte i/o."
|
||||
bool "Enable block I/O (larger/faster) instead of byte I/O"
|
||||
default n
|
||||
depends on TEE
|
||||
help
|
||||
|
||||
@@ -12,6 +12,7 @@ lib-$(CONFIG_CAL) += cal.o
|
||||
lib-$(CONFIG_CAT) += cat.o
|
||||
lib-$(CONFIG_MORE) += cat.o # more uses it if stdout isn't a tty
|
||||
lib-$(CONFIG_LESS) += cat.o # less too
|
||||
lib-$(CONFIG_CRONTAB) += cat.o # crontab -l
|
||||
lib-$(CONFIG_CATV) += catv.o
|
||||
lib-$(CONFIG_CHGRP) += chgrp.o chown.o
|
||||
lib-$(CONFIG_CHMOD) += chmod.o
|
||||
@@ -66,6 +67,7 @@ lib-$(CONFIG_STAT) += stat.o
|
||||
lib-$(CONFIG_STTY) += stty.o
|
||||
lib-$(CONFIG_SUM) += sum.o
|
||||
lib-$(CONFIG_SYNC) += sync.o
|
||||
lib-$(CONFIG_TAC) += tac.o
|
||||
lib-$(CONFIG_TAIL) += tail.o
|
||||
lib-$(CONFIG_TEE) += tee.o
|
||||
lib-$(CONFIG_TEST) += test.o
|
||||
|
||||
+4
-8
@@ -17,20 +17,16 @@
|
||||
|
||||
int bb_cat(char **argv)
|
||||
{
|
||||
static const char *const argv_dash[] = { "-", NULL };
|
||||
|
||||
int fd;
|
||||
int retval = EXIT_SUCCESS;
|
||||
|
||||
if (!*argv)
|
||||
argv = (char**) &argv_dash;
|
||||
argv = (char**) &bb_argv_dash;
|
||||
|
||||
do {
|
||||
fd = STDIN_FILENO;
|
||||
if (!LONE_DASH(*argv))
|
||||
fd = open_or_warn(*argv, O_RDONLY);
|
||||
fd = open_or_warn_stdin(*argv);
|
||||
if (fd >= 0) {
|
||||
/* This is not an xfunc - never exits */
|
||||
/* This is not a xfunc - never exits */
|
||||
off_t r = bb_copyfd_eof(fd, STDOUT_FILENO);
|
||||
if (fd != STDIN_FILENO)
|
||||
close(fd);
|
||||
@@ -44,7 +40,7 @@ int bb_cat(char **argv)
|
||||
}
|
||||
|
||||
int cat_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int cat_main(int argc, char **argv)
|
||||
int cat_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
getopt32(argv, "u");
|
||||
argv += optind;
|
||||
|
||||
+4
-8
@@ -13,7 +13,7 @@
|
||||
#include "libbb.h"
|
||||
|
||||
int catv_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int catv_main(int argc, char **argv)
|
||||
int catv_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
int retval = EXIT_SUCCESS;
|
||||
int fd;
|
||||
@@ -27,18 +27,14 @@ int catv_main(int argc, char **argv)
|
||||
argv += optind;
|
||||
|
||||
/* Read from stdin if there's nothing else to do. */
|
||||
fd = 0;
|
||||
if (!argv[0]) {
|
||||
argv--;
|
||||
goto jump_in;
|
||||
}
|
||||
if (!argv[0])
|
||||
*--argv = (char*)"-";
|
||||
do {
|
||||
fd = open_or_warn(*argv, O_RDONLY);
|
||||
fd = open_or_warn_stdin(*argv);
|
||||
if (fd < 0) {
|
||||
retval = EXIT_FAILURE;
|
||||
continue;
|
||||
}
|
||||
jump_in:
|
||||
for (;;) {
|
||||
int i, res;
|
||||
|
||||
|
||||
+1
-1
@@ -68,7 +68,7 @@ static int fileAction(const char *fileName, struct stat *statbuf, void* param, i
|
||||
}
|
||||
|
||||
int chmod_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int chmod_main(int argc, char **argv)
|
||||
int chmod_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
int retval = EXIT_SUCCESS;
|
||||
char *arg, **argp;
|
||||
|
||||
+2
-2
@@ -42,7 +42,7 @@ typedef int (*chown_fptr)(const char *, uid_t, gid_t);
|
||||
static struct bb_uidgid_t ugid = { -1, -1 };
|
||||
|
||||
static int fileAction(const char *fileName, struct stat *statbuf,
|
||||
void *cf, int depth)
|
||||
void *cf, int depth ATTRIBUTE_UNUSED)
|
||||
{
|
||||
uid_t u = (ugid.uid == (uid_t)-1) ? statbuf->st_uid : ugid.uid;
|
||||
gid_t g = (ugid.gid == (gid_t)-1) ? statbuf->st_gid : ugid.gid;
|
||||
@@ -62,7 +62,7 @@ static int fileAction(const char *fileName, struct stat *statbuf,
|
||||
}
|
||||
|
||||
int chown_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int chown_main(int argc, char **argv)
|
||||
int chown_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
int retval = EXIT_SUCCESS;
|
||||
int flags;
|
||||
|
||||
+1
-3
@@ -19,9 +19,7 @@ int chroot_main(int argc, char **argv)
|
||||
}
|
||||
|
||||
++argv;
|
||||
if (chroot(*argv)) {
|
||||
bb_perror_msg_and_die("cannot change root directory to %s", *argv);
|
||||
}
|
||||
xchroot(*argv);
|
||||
xchdir("/");
|
||||
|
||||
++argv;
|
||||
|
||||
+20
-18
@@ -9,46 +9,48 @@
|
||||
#include "libbb.h"
|
||||
|
||||
int cksum_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int cksum_main(int argc, char **argv)
|
||||
int cksum_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
uint32_t *crc32_table = crc32_filltable(NULL, 1);
|
||||
|
||||
FILE *fp;
|
||||
uint32_t crc;
|
||||
long length, filesize;
|
||||
int bytes_read;
|
||||
char *cp;
|
||||
uint8_t *cp;
|
||||
|
||||
int inp_stdin = (argc == optind) ? 1 : 0;
|
||||
#if ENABLE_DESKTOP
|
||||
getopt32(argv, ""); /* coreutils 6.9 compat */
|
||||
argv += optind;
|
||||
#else
|
||||
argv++;
|
||||
#endif
|
||||
|
||||
do {
|
||||
fp = fopen_or_warn_stdin((inp_stdin) ? bb_msg_standard_input : *++argv);
|
||||
int fd = open_or_warn_stdin(*argv ? *argv : bb_msg_standard_input);
|
||||
|
||||
if (fd < 0)
|
||||
continue;
|
||||
crc = 0;
|
||||
length = 0;
|
||||
|
||||
#define read_buf bb_common_bufsiz1
|
||||
while ((bytes_read = fread(read_buf, 1, BUFSIZ, fp)) > 0) {
|
||||
while ((bytes_read = safe_read(fd, read_buf, sizeof(read_buf))) > 0) {
|
||||
cp = read_buf;
|
||||
length += bytes_read;
|
||||
while (bytes_read--)
|
||||
crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ (*cp++)) & 0xffL];
|
||||
do {
|
||||
crc = (crc << 8) ^ crc32_table[(crc >> 24) ^ *cp++];
|
||||
} while (--bytes_read);
|
||||
}
|
||||
close(fd);
|
||||
|
||||
filesize = length;
|
||||
|
||||
for (; length; length >>= 8)
|
||||
crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ length) & 0xffL];
|
||||
crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ length) & 0xff];
|
||||
crc ^= 0xffffffffL;
|
||||
|
||||
if (inp_stdin) {
|
||||
printf("%" PRIu32 " %li\n", crc, filesize);
|
||||
break;
|
||||
}
|
||||
|
||||
printf("%" PRIu32 " %li %s\n", crc, filesize, *argv);
|
||||
fclose(fp);
|
||||
} while (*(argv + 1));
|
||||
printf((*argv ? "%" PRIu32 " %li %s\n" : "%" PRIu32 " %li\n"),
|
||||
crc, filesize, *argv);
|
||||
} while (*argv && *++argv);
|
||||
|
||||
fflush_stdout_and_exit(EXIT_SUCCESS);
|
||||
}
|
||||
+1
-1
@@ -36,7 +36,7 @@ static void writeline(char *line, int class, int flags)
|
||||
}
|
||||
|
||||
int comm_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int comm_main(int argc, char **argv)
|
||||
int comm_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
#define LINE_LEN 100
|
||||
#define BB_EOF_0 0x1
|
||||
|
||||
+32
-41
@@ -16,13 +16,11 @@
|
||||
|
||||
/* option vars */
|
||||
static const char optstring[] ALIGN1 = "b:c:f:d:sn";
|
||||
#define CUT_OPT_BYTE_FLGS (1<<0)
|
||||
#define CUT_OPT_CHAR_FLGS (1<<1)
|
||||
#define CUT_OPT_FIELDS_FLGS (1<<2)
|
||||
#define CUT_OPT_DELIM_FLGS (1<<3)
|
||||
#define CUT_OPT_SUPPRESS_FLGS (1<<4)
|
||||
|
||||
static char delim = '\t'; /* delimiter, default is tab */
|
||||
#define CUT_OPT_BYTE_FLGS (1 << 0)
|
||||
#define CUT_OPT_CHAR_FLGS (1 << 1)
|
||||
#define CUT_OPT_FIELDS_FLGS (1 << 2)
|
||||
#define CUT_OPT_DELIM_FLGS (1 << 3)
|
||||
#define CUT_OPT_SUPPRESS_FLGS (1 << 4)
|
||||
|
||||
struct cut_list {
|
||||
int startpos;
|
||||
@@ -47,7 +45,7 @@ static int cmpfunc(const void *a, const void *b)
|
||||
|
||||
}
|
||||
|
||||
static void cut_file(FILE * file)
|
||||
static void cut_file(FILE *file, char delim)
|
||||
{
|
||||
char *line = NULL;
|
||||
unsigned int linenum = 0; /* keep these zero-based to be consistent */
|
||||
@@ -163,11 +161,10 @@ static void cut_file(FILE * file)
|
||||
}
|
||||
}
|
||||
|
||||
static const char _op_on_field[] ALIGN1 = " only when operating on fields";
|
||||
|
||||
int cut_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int cut_main(int argc, char **argv)
|
||||
int cut_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
char delim = '\t'; /* delimiter, default is tab */
|
||||
char *sopt, *ltok;
|
||||
|
||||
opt_complementary = "b--bcf:c--bcf:f--bcf";
|
||||
@@ -178,7 +175,7 @@ int cut_main(int argc, char **argv)
|
||||
bb_error_msg_and_die("expected a list of bytes, characters, or fields");
|
||||
|
||||
if (option_mask32 & CUT_OPT_DELIM_FLGS) {
|
||||
if (strlen(ltok) > 1) {
|
||||
if (ltok[0] && ltok[1]) { /* more than 1 char? */
|
||||
bb_error_msg_and_die("the delimiter must be a single character");
|
||||
}
|
||||
delim = ltok[0];
|
||||
@@ -186,6 +183,8 @@ int cut_main(int argc, char **argv)
|
||||
|
||||
/* non-field (char or byte) cutting has some special handling */
|
||||
if (!(option_mask32 & CUT_OPT_FIELDS_FLGS)) {
|
||||
static const char _op_on_field[] ALIGN1 = " only when operating on fields";
|
||||
|
||||
if (option_mask32 & CUT_OPT_SUPPRESS_FLGS) {
|
||||
bb_error_msg_and_die
|
||||
("suppressing non-delimited lines makes sense%s",
|
||||
@@ -206,19 +205,16 @@ int cut_main(int argc, char **argv)
|
||||
char *ntok;
|
||||
int s = 0, e = 0;
|
||||
|
||||
/* take apart the lists, one by one (they are separated with commas */
|
||||
/* take apart the lists, one by one (they are separated with commas) */
|
||||
while ((ltok = strsep(&sopt, ",")) != NULL) {
|
||||
|
||||
/* it's actually legal to pass an empty list */
|
||||
if (strlen(ltok) == 0)
|
||||
if (!ltok[0])
|
||||
continue;
|
||||
|
||||
/* get the start pos */
|
||||
ntok = strsep(<ok, "-");
|
||||
if (ntok == NULL) {
|
||||
bb_error_msg
|
||||
("internal error: ntok is null for start pos!?\n");
|
||||
} else if (strlen(ntok) == 0) {
|
||||
if (!ntok[0]) {
|
||||
s = BOL;
|
||||
} else {
|
||||
s = xatoi_u(ntok);
|
||||
@@ -229,13 +225,12 @@ int cut_main(int argc, char **argv)
|
||||
}
|
||||
|
||||
/* get the end pos */
|
||||
ntok = strsep(<ok, "-");
|
||||
if (ntok == NULL) {
|
||||
if (ltok == NULL) {
|
||||
e = NON_RANGE;
|
||||
} else if (strlen(ntok) == 0) {
|
||||
} else if (!ltok[0]) {
|
||||
e = EOL;
|
||||
} else {
|
||||
e = xatoi_u(ntok);
|
||||
e = xatoi_u(ltok);
|
||||
/* if the user specified and end position of 0, that means "til the
|
||||
* end of the line */
|
||||
if (e == 0)
|
||||
@@ -245,11 +240,6 @@ int cut_main(int argc, char **argv)
|
||||
e = NON_RANGE;
|
||||
}
|
||||
|
||||
/* if there's something left to tokenize, the user passed
|
||||
* an invalid list */
|
||||
if (ltok)
|
||||
bb_error_msg_and_die("invalid byte or field list");
|
||||
|
||||
/* add the new list */
|
||||
cut_lists = xrealloc(cut_lists, sizeof(struct cut_list) * (++nlists));
|
||||
cut_lists[nlists-1].startpos = s;
|
||||
@@ -266,23 +256,24 @@ int cut_main(int argc, char **argv)
|
||||
qsort(cut_lists, nlists, sizeof(struct cut_list), cmpfunc);
|
||||
}
|
||||
|
||||
/* argv[0..argc-1] should be names of file to process. If no
|
||||
* files were specified or '-' was specified, take input from stdin.
|
||||
* Otherwise, we process all the files specified. */
|
||||
if (argv[0] == NULL || LONE_DASH(argv[0])) {
|
||||
cut_file(stdin);
|
||||
} else {
|
||||
FILE *file;
|
||||
{
|
||||
int retval = EXIT_SUCCESS;
|
||||
|
||||
if (!*argv)
|
||||
*--argv = (char *)"-";
|
||||
|
||||
do {
|
||||
file = fopen_or_warn(argv[0], "r");
|
||||
if (file) {
|
||||
cut_file(file);
|
||||
fclose(file);
|
||||
FILE *file = fopen_or_warn_stdin(*argv);
|
||||
if (!file) {
|
||||
retval = EXIT_FAILURE;
|
||||
continue;
|
||||
}
|
||||
cut_file(file, delim);
|
||||
fclose_if_not_stdin(file);
|
||||
} while (*++argv);
|
||||
|
||||
if (ENABLE_FEATURE_CLEAN_UP)
|
||||
free(cut_lists);
|
||||
fflush_stdout_and_exit(retval);
|
||||
}
|
||||
if (ENABLE_FEATURE_CLEAN_UP)
|
||||
free(cut_lists);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
+55
-59
@@ -14,6 +14,11 @@
|
||||
/* This is a NOEXEC applet. Be very careful! */
|
||||
|
||||
|
||||
enum {
|
||||
ifd = STDIN_FILENO,
|
||||
ofd = STDOUT_FILENO,
|
||||
};
|
||||
|
||||
static const struct suffix_mult dd_suffixes[] = {
|
||||
{ "c", 1 },
|
||||
{ "w", 2 },
|
||||
@@ -45,19 +50,19 @@ static void dd_output_status(int ATTRIBUTE_UNUSED cur_signal)
|
||||
G.out_full, G.out_part);
|
||||
}
|
||||
|
||||
static ssize_t full_write_or_warn(int fd, const void *buf, size_t len,
|
||||
static ssize_t full_write_or_warn(const void *buf, size_t len,
|
||||
const char *const filename)
|
||||
{
|
||||
ssize_t n = full_write(fd, buf, len);
|
||||
ssize_t n = full_write(ofd, buf, len);
|
||||
if (n < 0)
|
||||
bb_perror_msg("writing '%s'", filename);
|
||||
return n;
|
||||
}
|
||||
|
||||
static bool write_and_stats(int fd, const void *buf, size_t len, size_t obs,
|
||||
static bool write_and_stats(const void *buf, size_t len, size_t obs,
|
||||
const char *filename)
|
||||
{
|
||||
ssize_t n = full_write_or_warn(fd, buf, len, filename);
|
||||
ssize_t n = full_write_or_warn(buf, len, filename);
|
||||
if (n < 0)
|
||||
return 1;
|
||||
if (n == obs)
|
||||
@@ -105,40 +110,32 @@ int dd_main(int argc, char **argv)
|
||||
OP_conv_noerror,
|
||||
#endif
|
||||
};
|
||||
int exitcode = EXIT_FAILURE;
|
||||
size_t ibs = 512, obs = 512;
|
||||
ssize_t n, w;
|
||||
char *ibuf, *obuf;
|
||||
/* And these are all zeroed at once! */
|
||||
struct {
|
||||
int flags;
|
||||
int ifd, ofd;
|
||||
size_t oc;
|
||||
off_t count;
|
||||
off_t seek, skip;
|
||||
const char *infile, *outfile;
|
||||
#if ENABLE_FEATURE_DD_SIGNAL_HANDLING
|
||||
struct sigaction sigact;
|
||||
#endif
|
||||
} Z;
|
||||
#define flags (Z.flags )
|
||||
#define ifd (Z.ifd )
|
||||
#define ofd (Z.ofd )
|
||||
#define oc (Z.oc )
|
||||
#define count (Z.count )
|
||||
#define seek (Z.seek )
|
||||
#define skip (Z.skip )
|
||||
#define infile (Z.infile )
|
||||
#define outfile (Z.outfile)
|
||||
#define sigact (Z.sigact )
|
||||
|
||||
memset(&Z, 0, sizeof(Z));
|
||||
INIT_G();
|
||||
//fflush(NULL); - is this needed because of NOEXEC?
|
||||
|
||||
#if ENABLE_FEATURE_DD_SIGNAL_HANDLING
|
||||
sigact.sa_handler = dd_output_status;
|
||||
sigact.sa_flags = SA_RESTART;
|
||||
sigemptyset(&sigact.sa_mask);
|
||||
sigaction(SIGUSR1, &sigact, NULL);
|
||||
signal_SA_RESTART_empty_mask(SIGUSR1, dd_output_status);
|
||||
#endif
|
||||
|
||||
for (n = 1; n < argc; n++) {
|
||||
@@ -160,40 +157,40 @@ int dd_main(int argc, char **argv)
|
||||
if (what == 0)
|
||||
bb_show_usage();
|
||||
arg += key_len;
|
||||
/* Must fit into positive ssize_t */
|
||||
#if ENABLE_FEATURE_DD_IBS_OBS
|
||||
if (what == OP_ibs) {
|
||||
ibs = xatoul_range_sfx(arg, 1, ((size_t)-1L)/2, dd_suffixes);
|
||||
continue;
|
||||
}
|
||||
if (what == OP_obs) {
|
||||
obs = xatoul_range_sfx(arg, 1, ((size_t)-1L)/2, dd_suffixes);
|
||||
continue;
|
||||
}
|
||||
if (what == OP_conv) {
|
||||
while (1) {
|
||||
/* find ',', replace them with nil so we can use arg for
|
||||
* index_in_strings() without copying.
|
||||
* We rely on arg being non-null, else strchr would fault.
|
||||
*/
|
||||
key = strchr(arg, ',');
|
||||
if (key)
|
||||
*key = '\0';
|
||||
what = index_in_strings(keywords, arg) + 1;
|
||||
if (what < OP_conv_notrunc)
|
||||
bb_error_msg_and_die(bb_msg_invalid_arg, arg, "conv");
|
||||
if (what == OP_conv_notrunc)
|
||||
flags |= FLAG_NOTRUNC;
|
||||
if (what == OP_conv_sync)
|
||||
flags |= FLAG_SYNC;
|
||||
if (what == OP_conv_noerror)
|
||||
flags |= FLAG_NOERROR;
|
||||
if (!key) /* no ',' left, so this was the last specifier */
|
||||
break;
|
||||
arg = key + 1; /* skip this keyword and ',' */
|
||||
}
|
||||
continue;
|
||||
if (what == OP_ibs) {
|
||||
/* Must fit into positive ssize_t */
|
||||
ibs = xatoul_range_sfx(arg, 1, ((size_t)-1L)/2, dd_suffixes);
|
||||
continue;
|
||||
}
|
||||
if (what == OP_obs) {
|
||||
obs = xatoul_range_sfx(arg, 1, ((size_t)-1L)/2, dd_suffixes);
|
||||
continue;
|
||||
}
|
||||
if (what == OP_conv) {
|
||||
while (1) {
|
||||
/* find ',', replace them with NUL so we can use arg for
|
||||
* index_in_strings() without copying.
|
||||
* We rely on arg being non-null, else strchr would fault.
|
||||
*/
|
||||
key = strchr(arg, ',');
|
||||
if (key)
|
||||
*key = '\0';
|
||||
what = index_in_strings(keywords, arg) + 1;
|
||||
if (what < OP_conv_notrunc)
|
||||
bb_error_msg_and_die(bb_msg_invalid_arg, arg, "conv");
|
||||
if (what == OP_conv_notrunc)
|
||||
flags |= FLAG_NOTRUNC;
|
||||
if (what == OP_conv_sync)
|
||||
flags |= FLAG_SYNC;
|
||||
if (what == OP_conv_noerror)
|
||||
flags |= FLAG_NOERROR;
|
||||
if (!key) /* no ',' left, so this was the last specifier */
|
||||
break;
|
||||
arg = key + 1; /* skip this keyword and ',' */
|
||||
}
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
if (what == OP_bs) {
|
||||
ibs = obs = xatoul_range_sfx(arg, 1, ((size_t)-1L)/2, dd_suffixes);
|
||||
@@ -227,9 +224,8 @@ int dd_main(int argc, char **argv)
|
||||
obuf = xmalloc(obs);
|
||||
}
|
||||
if (infile != NULL)
|
||||
ifd = xopen(infile, O_RDONLY);
|
||||
xmove_fd(xopen(infile, O_RDONLY), ifd);
|
||||
else {
|
||||
/* ifd = STDIN_FILENO; - it's zero and it's already there */
|
||||
infile = bb_msg_standard_input;
|
||||
}
|
||||
if (outfile != NULL) {
|
||||
@@ -238,7 +234,7 @@ int dd_main(int argc, char **argv)
|
||||
if (!seek && !(flags & FLAG_NOTRUNC))
|
||||
oflag |= O_TRUNC;
|
||||
|
||||
ofd = xopen(outfile, oflag);
|
||||
xmove_fd(xopen(outfile, oflag), ofd);
|
||||
|
||||
if (seek && !(flags & FLAG_NOTRUNC)) {
|
||||
if (ftruncate(ofd, seek * obs) < 0) {
|
||||
@@ -250,7 +246,6 @@ int dd_main(int argc, char **argv)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
ofd = STDOUT_FILENO;
|
||||
outfile = bb_msg_standard_output;
|
||||
}
|
||||
if (skip) {
|
||||
@@ -276,11 +271,10 @@ int dd_main(int argc, char **argv)
|
||||
if (n == 0)
|
||||
break;
|
||||
if (n < 0) {
|
||||
if (flags & FLAG_NOERROR) {
|
||||
n = ibs;
|
||||
bb_simple_perror_msg(infile);
|
||||
} else
|
||||
if (!(flags & FLAG_NOERROR))
|
||||
goto die_infile;
|
||||
n = ibs;
|
||||
bb_simple_perror_msg(infile);
|
||||
}
|
||||
if ((size_t)n == ibs)
|
||||
G.in_full++;
|
||||
@@ -303,17 +297,17 @@ int dd_main(int argc, char **argv)
|
||||
tmp += d;
|
||||
oc += d;
|
||||
if (oc == obs) {
|
||||
if (write_and_stats(ofd, obuf, obs, obs, outfile))
|
||||
if (write_and_stats(obuf, obs, obs, outfile))
|
||||
goto out_status;
|
||||
oc = 0;
|
||||
}
|
||||
}
|
||||
} else if (write_and_stats(ofd, ibuf, n, obs, outfile))
|
||||
} else if (write_and_stats(ibuf, n, obs, outfile))
|
||||
goto out_status;
|
||||
}
|
||||
|
||||
if (ENABLE_FEATURE_DD_IBS_OBS && oc) {
|
||||
w = full_write_or_warn(ofd, obuf, oc, outfile);
|
||||
w = full_write_or_warn(obuf, oc, outfile);
|
||||
if (w < 0) goto out_status;
|
||||
if (w > 0)
|
||||
G.out_part++;
|
||||
@@ -327,8 +321,10 @@ int dd_main(int argc, char **argv)
|
||||
die_outfile:
|
||||
bb_simple_perror_msg_and_die(outfile);
|
||||
}
|
||||
|
||||
exitcode = EXIT_SUCCESS;
|
||||
out_status:
|
||||
dd_output_status(0);
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
return exitcode;
|
||||
}
|
||||
+32
-8
@@ -45,23 +45,32 @@ int df_main(int argc, char **argv)
|
||||
/* default display is kilobytes */
|
||||
const char *disp_units_hdr = "1k-blocks";
|
||||
|
||||
enum {
|
||||
OPT_ALL = (1 << 0),
|
||||
OPT_INODE = (ENABLE_FEATURE_HUMAN_READABLE ? (1 << 4) : (1 << 2))
|
||||
* ENABLE_FEATURE_DF_INODE
|
||||
};
|
||||
|
||||
#if ENABLE_FEATURE_HUMAN_READABLE
|
||||
opt_complementary = "h-km:k-hm:m-hk";
|
||||
opt = getopt32(argv, "hmk");
|
||||
if (opt & 1) {
|
||||
opt = getopt32(argv, "ahmk" USE_FEATURE_DF_INODE("i"));
|
||||
if (opt & (1 << 1)) { // -h
|
||||
df_disp_hr = 0;
|
||||
disp_units_hdr = " Size";
|
||||
}
|
||||
if (opt & 2) {
|
||||
if (opt & (1 << 2)) { // -m
|
||||
df_disp_hr = 1024*1024;
|
||||
disp_units_hdr = "1M-blocks";
|
||||
}
|
||||
if (opt & OPT_INODE) {
|
||||
disp_units_hdr = " Inodes";
|
||||
}
|
||||
#else
|
||||
opt = getopt32(argv, "k");
|
||||
opt = getopt32(argv, "ak" USE_FEATURE_DF_INODE("i"));
|
||||
#endif
|
||||
|
||||
printf("Filesystem%11s%-15sUsed Available Use%% Mounted on\n",
|
||||
"", disp_units_hdr);
|
||||
printf("Filesystem %-15sUsed Available Use%% Mounted on\n",
|
||||
disp_units_hdr);
|
||||
|
||||
mount_table = NULL;
|
||||
argv += optind;
|
||||
@@ -104,7 +113,16 @@ int df_main(int argc, char **argv)
|
||||
goto SET_ERROR;
|
||||
}
|
||||
|
||||
if ((s.f_blocks > 0) || !mount_table){
|
||||
if ((s.f_blocks > 0) || !mount_table || (opt & OPT_ALL)) {
|
||||
if (opt & OPT_INODE) {
|
||||
s.f_blocks = s.f_files;
|
||||
s.f_bavail = s.f_bfree = s.f_ffree;
|
||||
s.f_bsize = 1;
|
||||
#if ENABLE_FEATURE_HUMAN_READABLE
|
||||
if (df_disp_hr)
|
||||
df_disp_hr = 1;
|
||||
#endif
|
||||
}
|
||||
blocks_used = s.f_blocks - s.f_bfree;
|
||||
blocks_percent_used = 0;
|
||||
if (blocks_used + s.f_bavail) {
|
||||
@@ -113,9 +131,14 @@ int df_main(int argc, char **argv)
|
||||
) / (blocks_used + s.f_bavail);
|
||||
}
|
||||
|
||||
#ifdef WHY_IT_SHOULD_BE_HIDDEN
|
||||
if (strcmp(device, "rootfs") == 0) {
|
||||
continue;
|
||||
} else if (strcmp(device, "/dev/root") == 0) {
|
||||
}
|
||||
#endif
|
||||
#ifdef WHY_WE_DO_IT_FOR_DEV_ROOT_ONLY
|
||||
/* ... and also this is the only user of find_block_device */
|
||||
if (strcmp(device, "/dev/root") == 0) {
|
||||
/* Adjusts device to be the real root device,
|
||||
* or leaves device alone if it can't find it */
|
||||
device = find_block_device("/");
|
||||
@@ -123,6 +146,7 @@ int df_main(int argc, char **argv)
|
||||
goto SET_ERROR;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (printf("\n%-20s" + 1, device) > 20)
|
||||
printf("\n%-20s", "");
|
||||
|
||||
+19
-35
@@ -20,62 +20,49 @@ enum {
|
||||
};
|
||||
|
||||
/* if fn is NULL then input is stdin and output is stdout */
|
||||
static int convert(char *fn, int conv_type)
|
||||
static void convert(char *fn, int conv_type)
|
||||
{
|
||||
FILE *in, *out;
|
||||
int i;
|
||||
#define name_buf bb_common_bufsiz1
|
||||
char *name_buf = name_buf; /* for compiler */
|
||||
|
||||
in = stdin;
|
||||
out = stdout;
|
||||
if (fn != NULL) {
|
||||
in = xfopen(fn, "rw");
|
||||
in = xfopen(fn, "r");
|
||||
/*
|
||||
The file is then created with mode read/write and
|
||||
permissions 0666 for glibc 2.0.6 and earlier or
|
||||
0600 for glibc 2.0.7 and later.
|
||||
*/
|
||||
snprintf(name_buf, sizeof(name_buf), "%sXXXXXX", fn);
|
||||
i = mkstemp(&name_buf[0]);
|
||||
if (i == -1 || chmod(name_buf, 0600) == -1) {
|
||||
name_buf = xasprintf("%sXXXXXX", fn);
|
||||
i = mkstemp(name_buf);
|
||||
if (i == -1
|
||||
|| fchmod(i, 0600) == -1
|
||||
|| !(out = fdopen(i, "w+"))
|
||||
) {
|
||||
bb_perror_nomsg_and_die();
|
||||
}
|
||||
out = fdopen(i, "w+");
|
||||
if (!out) {
|
||||
close(i);
|
||||
remove(name_buf);
|
||||
return -2;
|
||||
}
|
||||
}
|
||||
|
||||
while ((i = fgetc(in)) != EOF) {
|
||||
if (i == '\r')
|
||||
continue;
|
||||
if (i == '\n') {
|
||||
if (i == '\n')
|
||||
if (conv_type == CT_UNIX2DOS)
|
||||
fputc('\r', out);
|
||||
fputc('\n', out);
|
||||
continue;
|
||||
}
|
||||
fputc(i, out);
|
||||
}
|
||||
|
||||
if (fn != NULL) {
|
||||
if (fclose(in) < 0 || fclose(out) < 0) {
|
||||
bb_perror_nomsg();
|
||||
remove(name_buf);
|
||||
return -2;
|
||||
}
|
||||
/* Assume they are both on the same filesystem (which
|
||||
* should be true since we put them into the same directory
|
||||
* so we _should_ be ok, but you never know... */
|
||||
if (rename(name_buf, fn) < 0) {
|
||||
bb_perror_msg("cannot rename '%s' as '%s'", name_buf, fn);
|
||||
return -1;
|
||||
unlink(name_buf);
|
||||
bb_perror_nomsg_and_die();
|
||||
}
|
||||
// TODO: destroys symlinks. See how passwd handles this
|
||||
xrename(name_buf, fn);
|
||||
free(name_buf);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int dos2unix_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
@@ -84,10 +71,9 @@ int dos2unix_main(int argc, char **argv)
|
||||
int o, conv_type;
|
||||
|
||||
/* See if we are supposed to be doing dos2unix or unix2dos */
|
||||
conv_type = CT_UNIX2DOS;
|
||||
if (applet_name[0] == 'd') {
|
||||
conv_type = CT_DOS2UNIX; /* 2 */
|
||||
} else {
|
||||
conv_type = CT_UNIX2DOS; /* 1 */
|
||||
conv_type = CT_DOS2UNIX;
|
||||
}
|
||||
|
||||
/* -u convert to unix, -d convert to dos */
|
||||
@@ -101,11 +87,9 @@ int dos2unix_main(int argc, char **argv)
|
||||
|
||||
do {
|
||||
/* might be convert(NULL) if there is no filename given */
|
||||
o = convert(argv[optind], conv_type);
|
||||
if (o < 0)
|
||||
break;
|
||||
convert(argv[optind], conv_type);
|
||||
optind++;
|
||||
} while (optind < argc);
|
||||
|
||||
return o;
|
||||
return 0;
|
||||
}
|
||||
+5
-10
@@ -141,12 +141,11 @@ static unsigned long du(const char *filename)
|
||||
}
|
||||
|
||||
int du_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int du_main(int argc, char **argv)
|
||||
int du_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
unsigned long total;
|
||||
int slink_depth_save;
|
||||
bool print_final_total;
|
||||
char *smax_print_depth;
|
||||
unsigned opt;
|
||||
|
||||
#if ENABLE_FEATURE_HUMAN_READABLE
|
||||
@@ -168,8 +167,8 @@ int du_main(int argc, char **argv)
|
||||
* ignore -a. This is consistent with -s being equivalent to -d 0.
|
||||
*/
|
||||
#if ENABLE_FEATURE_HUMAN_READABLE
|
||||
opt_complementary = "h-km:k-hm:m-hk:H-L:L-H:s-d:d-s";
|
||||
opt = getopt32(argv, "aHkLsx" "d:" "lc" "hm", &smax_print_depth);
|
||||
opt_complementary = "h-km:k-hm:m-hk:H-L:L-H:s-d:d-s:d+";
|
||||
opt = getopt32(argv, "aHkLsx" "d:" "lc" "hm", &G.max_print_depth);
|
||||
argv += optind;
|
||||
if (opt & (1 << 9)) {
|
||||
/* -h opt */
|
||||
@@ -184,8 +183,8 @@ int du_main(int argc, char **argv)
|
||||
G.disp_hr = 1024;
|
||||
}
|
||||
#else
|
||||
opt_complementary = "H-L:L-H:s-d:d-s";
|
||||
opt = getopt32(argv, "aHkLsx" "d:" "lc", &smax_print_depth);
|
||||
opt_complementary = "H-L:L-H:s-d:d-s:d+";
|
||||
opt = getopt32(argv, "aHkLsx" "d:" "lc", &G.max_print_depth);
|
||||
argv += optind;
|
||||
#if !ENABLE_FEATURE_DU_DEFAULT_BLOCKSIZE_1K
|
||||
if (opt & (1 << 2)) {
|
||||
@@ -211,10 +210,6 @@ int du_main(int argc, char **argv)
|
||||
G.max_print_depth = 0;
|
||||
}
|
||||
G.one_file_system = opt & (1 << 5); /* -x opt */
|
||||
if (opt & (1 << 6)) {
|
||||
/* -d opt */
|
||||
G.max_print_depth = xatoi_u(smax_print_depth);
|
||||
}
|
||||
if (opt & (1 << 7)) {
|
||||
/* -l opt */
|
||||
G.count_hardlinks = MAXINT(nlink_t);
|
||||
|
||||
+148
-13
@@ -25,7 +25,11 @@
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
int bb_echo(char **argv)
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
/* NB: can be used by shell even if not enabled as applet */
|
||||
|
||||
int echo_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
const char *arg;
|
||||
#if !ENABLE_FEATURE_FANCY_ECHO
|
||||
@@ -33,6 +37,18 @@ int bb_echo(char **argv)
|
||||
eflag = '\\',
|
||||
nflag = 1, /* 1 -- print '\n' */
|
||||
};
|
||||
|
||||
/* We must check that stdout is not closed.
|
||||
* The reason for this is highly non-obvious.
|
||||
* echo_main is used from shell. Shell must correctly handle "echo foo"
|
||||
* if stdout is closed. With stdio, output gets shoveled into
|
||||
* stdout buffer, and even fflush cannot clear it out. It seems that
|
||||
* even if libc receives EBADF on write attempts, it feels determined
|
||||
* to output data no matter what. So it will try later,
|
||||
* and possibly will clobber future output. Not good. */
|
||||
if (dup2(1, 1) != 1)
|
||||
return -1;
|
||||
|
||||
arg = *++argv;
|
||||
if (!arg)
|
||||
goto newline_ret;
|
||||
@@ -41,6 +57,10 @@ int bb_echo(char **argv)
|
||||
char nflag = 1;
|
||||
char eflag = 0;
|
||||
|
||||
/* We must check that stdout is not closed. */
|
||||
if (dup2(1, 1) != 1)
|
||||
return -1;
|
||||
|
||||
while (1) {
|
||||
arg = *++argv;
|
||||
if (!arg)
|
||||
@@ -88,15 +108,19 @@ int bb_echo(char **argv)
|
||||
}
|
||||
#if !ENABLE_FEATURE_FANCY_ECHO
|
||||
/* SUSv3 specifies that octal escapes must begin with '0'. */
|
||||
if ( (((unsigned char)*arg) - '1') >= 7)
|
||||
if ( ((int)(unsigned char)(*arg) - '0') >= 8) /* '8' or bigger */
|
||||
#endif
|
||||
{
|
||||
/* Since SUSv3 mandates a first digit of 0, 4-digit octals
|
||||
* of the form \0### are accepted. */
|
||||
if (*arg == '0' && ((unsigned char)(arg[1]) - '0') < 8) {
|
||||
arg++;
|
||||
if (*arg == '0') {
|
||||
/* NB: don't turn "...\0" into "...\" */
|
||||
if (arg[1] && ((unsigned char)(arg[1]) - '0') < 8) {
|
||||
arg++;
|
||||
}
|
||||
}
|
||||
/* bb_process_escape_sequence can handle nul correctly */
|
||||
/* bb_process_escape_sequence handles NUL correctly
|
||||
* ("...\" case). */
|
||||
c = bb_process_escape_sequence(&arg);
|
||||
}
|
||||
}
|
||||
@@ -117,14 +141,6 @@ int bb_echo(char **argv)
|
||||
return fflush(stdout);
|
||||
}
|
||||
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
int echo_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int echo_main(int argc, char **argv)
|
||||
{
|
||||
return bb_echo(argv);
|
||||
}
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1991, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
@@ -163,3 +179,122 @@ int echo_main(int argc, char **argv)
|
||||
*
|
||||
* @(#)echo.c 8.1 (Berkeley) 5/31/93
|
||||
*/
|
||||
|
||||
#ifdef VERSION_WITH_WRITEV
|
||||
/* We can't use stdio.
|
||||
* The reason for this is highly non-obvious.
|
||||
* echo_main is used from shell. Shell must correctly handle "echo foo"
|
||||
* if stdout is closed. With stdio, output gets shoveled into
|
||||
* stdout buffer, and even fflush cannot clear it out. It seems that
|
||||
* even if libc receives EBADF on write attempts, it feels determined
|
||||
* to output data no matter what. So it will try later,
|
||||
* and possibly will clobber future output. Not good.
|
||||
*
|
||||
* Using writev instead, with 'direct' conversion of argv vector.
|
||||
*/
|
||||
|
||||
int echo_main(int argc, char **argv)
|
||||
{
|
||||
struct iovec io[argc];
|
||||
struct iovec *cur_io = io;
|
||||
char *arg;
|
||||
char *p;
|
||||
#if !ENABLE_FEATURE_FANCY_ECHO
|
||||
enum {
|
||||
eflag = '\\',
|
||||
nflag = 1, /* 1 -- print '\n' */
|
||||
};
|
||||
arg = *++argv;
|
||||
if (!arg)
|
||||
goto newline_ret;
|
||||
#else
|
||||
char nflag = 1;
|
||||
char eflag = 0;
|
||||
|
||||
while (1) {
|
||||
arg = *++argv;
|
||||
if (!arg)
|
||||
goto newline_ret;
|
||||
if (*arg != '-')
|
||||
break;
|
||||
|
||||
/* If it appears that we are handling options, then make sure
|
||||
* that all of the options specified are actually valid.
|
||||
* Otherwise, the string should just be echoed.
|
||||
*/
|
||||
p = arg + 1;
|
||||
if (!*p) /* A single '-', so echo it. */
|
||||
goto just_echo;
|
||||
|
||||
do {
|
||||
if (!strrchr("neE", *p))
|
||||
goto just_echo;
|
||||
} while (*++p);
|
||||
|
||||
/* All of the options in this arg are valid, so handle them. */
|
||||
p = arg + 1;
|
||||
do {
|
||||
if (*p == 'n')
|
||||
nflag = 0;
|
||||
if (*p == 'e')
|
||||
eflag = '\\';
|
||||
} while (*++p);
|
||||
}
|
||||
just_echo:
|
||||
#endif
|
||||
|
||||
while (1) {
|
||||
/* arg is already == *argv and isn't NULL */
|
||||
int c;
|
||||
|
||||
cur_io->iov_base = p = arg;
|
||||
|
||||
if (!eflag) {
|
||||
/* optimization for very common case */
|
||||
p += strlen(arg);
|
||||
} else while ((c = *arg++)) {
|
||||
if (c == eflag) { /* Check for escape seq. */
|
||||
if (*arg == 'c') {
|
||||
/* '\c' means cancel newline and
|
||||
* ignore all subsequent chars. */
|
||||
cur_io->iov_len = p - (char*)cur_io->iov_base;
|
||||
cur_io++;
|
||||
goto ret;
|
||||
}
|
||||
#if !ENABLE_FEATURE_FANCY_ECHO
|
||||
/* SUSv3 specifies that octal escapes must begin with '0'. */
|
||||
if ( (((unsigned char)*arg) - '1') >= 7)
|
||||
#endif
|
||||
{
|
||||
/* Since SUSv3 mandates a first digit of 0, 4-digit octals
|
||||
* of the form \0### are accepted. */
|
||||
if (*arg == '0' && ((unsigned char)(arg[1]) - '0') < 8) {
|
||||
arg++;
|
||||
}
|
||||
/* bb_process_escape_sequence can handle nul correctly */
|
||||
c = bb_process_escape_sequence( (void*) &arg);
|
||||
}
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
|
||||
arg = *++argv;
|
||||
if (arg)
|
||||
*p++ = ' ';
|
||||
cur_io->iov_len = p - (char*)cur_io->iov_base;
|
||||
cur_io++;
|
||||
if (!arg)
|
||||
break;
|
||||
}
|
||||
|
||||
newline_ret:
|
||||
if (nflag) {
|
||||
cur_io->iov_base = (char*)"\n";
|
||||
cur_io->iov_len = 1;
|
||||
cur_io++;
|
||||
}
|
||||
ret:
|
||||
/* TODO: implement and use full_writev? */
|
||||
return writev(1, io, (cur_io - io)) >= 0;
|
||||
}
|
||||
#endif
|
||||
+1
-3
@@ -30,8 +30,6 @@
|
||||
*/
|
||||
|
||||
#include <getopt.h> /* struct option */
|
||||
extern char **environ;
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
#if ENABLE_FEATURE_ENV_LONG_OPTIONS
|
||||
@@ -42,7 +40,7 @@ static const char env_longopts[] ALIGN1 =
|
||||
#endif
|
||||
|
||||
int env_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int env_main(int argc, char **argv)
|
||||
int env_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
/* cleanenv was static - why? */
|
||||
char *cleanenv[1];
|
||||
|
||||
+8
-17
@@ -126,7 +126,7 @@ static void unexpand(FILE *file, unsigned int tab_size, unsigned opt)
|
||||
#endif
|
||||
|
||||
int expand_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int expand_main(int argc, char **argv)
|
||||
int expand_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
/* Default 8 spaces for 1 tab */
|
||||
const char *opt_t = "8";
|
||||
@@ -154,7 +154,7 @@ int expand_main(int argc, char **argv)
|
||||
if (ENABLE_EXPAND && (!ENABLE_UNEXPAND || applet_name[0] == 'e')) {
|
||||
USE_FEATURE_EXPAND_LONG_OPTIONS(applet_long_options = expand_longopts);
|
||||
opt = getopt32(argv, "it:", &opt_t);
|
||||
} else if (ENABLE_UNEXPAND) {
|
||||
} else {
|
||||
USE_FEATURE_UNEXPAND_LONG_OPTIONS(applet_long_options = unexpand_longopts);
|
||||
/* -t NUM sets also -a */
|
||||
opt_complementary = "ta";
|
||||
@@ -166,32 +166,23 @@ int expand_main(int argc, char **argv)
|
||||
|
||||
argv += optind;
|
||||
|
||||
/* If no args are given, read from stdin */
|
||||
if (!*argv) {
|
||||
*--argv = (char*)bb_msg_standard_input;
|
||||
goto use_stdin;
|
||||
}
|
||||
|
||||
do {
|
||||
if (NOT_LONE_CHAR(*argv, '-')) {
|
||||
file = fopen_or_warn(*argv, "r");
|
||||
if (!file) {
|
||||
exit_status = EXIT_FAILURE;
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
use_stdin:
|
||||
file = stdin;
|
||||
file = fopen_or_warn_stdin(*argv);
|
||||
if (!file) {
|
||||
exit_status = EXIT_FAILURE;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ENABLE_EXPAND && (!ENABLE_UNEXPAND || applet_name[0] == 'e'))
|
||||
USE_EXPAND(expand(file, tab_size, opt));
|
||||
else if (ENABLE_UNEXPAND)
|
||||
else
|
||||
USE_UNEXPAND(unexpand(file, tab_size, opt));
|
||||
|
||||
/* Check and close the file */
|
||||
/* We do want all of them to execute, thus | instead of || */
|
||||
if (ferror(file) | fclose_if_not_stdin(file)) {
|
||||
if (fclose_if_not_stdin(file)) {
|
||||
bb_simple_perror_msg(*argv);
|
||||
exit_status = EXIT_FAILURE;
|
||||
}
|
||||
|
||||
+13
-16
@@ -12,18 +12,17 @@
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
static unsigned long flags;
|
||||
#define FLAG_COUNT_BYTES 1
|
||||
#define FLAG_BREAK_SPACES 2
|
||||
#define FLAG_WIDTH 4
|
||||
/* Must match getopt32 call */
|
||||
#define FLAG_COUNT_BYTES 1
|
||||
#define FLAG_BREAK_SPACES 2
|
||||
#define FLAG_WIDTH 4
|
||||
|
||||
/* Assuming the current column is COLUMN, return the column that
|
||||
printing C will move the cursor to.
|
||||
The first column is 0. */
|
||||
|
||||
static int adjust_column(int column, char c)
|
||||
{
|
||||
if (!(flags & FLAG_COUNT_BYTES)) {
|
||||
if (!(option_mask32 & FLAG_COUNT_BYTES)) {
|
||||
if (c == '\b') {
|
||||
if (column > 0)
|
||||
column--;
|
||||
@@ -54,29 +53,27 @@ int fold_main(int argc, char **argv)
|
||||
char const *a = argv[i];
|
||||
|
||||
if (*a++ == '-') {
|
||||
if (*a == '-' && !a[1])
|
||||
if (*a == '-' && !a[1]) /* "--" */
|
||||
break;
|
||||
if (isdigit(*a)) {
|
||||
if (isdigit(*a))
|
||||
argv[i] = xasprintf("-w%s", a);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
flags = getopt32(argv, "bsw:", &w_opt);
|
||||
if (flags & FLAG_WIDTH)
|
||||
getopt32(argv, "bsw:", &w_opt);
|
||||
if (option_mask32 & FLAG_WIDTH)
|
||||
width = xatoul_range(w_opt, 1, 10000);
|
||||
|
||||
argv += optind;
|
||||
if (!*argv) {
|
||||
if (!*argv)
|
||||
*--argv = (char*)"-";
|
||||
}
|
||||
|
||||
do {
|
||||
FILE *istream = fopen_or_warn_stdin(*argv);
|
||||
int c;
|
||||
int column = 0; /* Screen column where next char will go. */
|
||||
int offset_out = 0; /* Index in `line_out' for next char. */
|
||||
int offset_out = 0; /* Index in 'line_out' for next char. */
|
||||
|
||||
if (istream == NULL) {
|
||||
errs |= EXIT_FAILURE;
|
||||
@@ -102,7 +99,7 @@ int fold_main(int argc, char **argv)
|
||||
/* This character would make the line too long.
|
||||
Print the line plus a newline, and make this character
|
||||
start the next line. */
|
||||
if (flags & FLAG_BREAK_SPACES) {
|
||||
if (option_mask32 & FLAG_BREAK_SPACES) {
|
||||
/* Look for the last blank. */
|
||||
int logical_end;
|
||||
|
||||
@@ -144,7 +141,7 @@ int fold_main(int argc, char **argv)
|
||||
fwrite(line_out, sizeof(char), (size_t) offset_out, stdout);
|
||||
}
|
||||
|
||||
if (ferror(istream) || fclose_if_not_stdin(istream)) {
|
||||
if (fclose_if_not_stdin(istream)) {
|
||||
bb_simple_perror_msg(*argv); /* Avoid multibyte problems. */
|
||||
errs |= EXIT_FAILURE;
|
||||
}
|
||||
|
||||
+5
-5
@@ -91,19 +91,19 @@ int head_main(int argc, char **argv)
|
||||
}
|
||||
}
|
||||
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
if (!*argv) {
|
||||
if (!*argv)
|
||||
*--argv = (char*)"-";
|
||||
}
|
||||
|
||||
fmt = header_fmt_str + 1;
|
||||
#if ENABLE_FEATURE_FANCY_HEAD
|
||||
if (argc - optind <= header_threshhold) {
|
||||
if (argc <= header_threshhold) {
|
||||
header_threshhold = 0;
|
||||
}
|
||||
#else
|
||||
if (argc <= optind + 1) {
|
||||
fmt += 11;
|
||||
if (argc <= 1) {
|
||||
fmt += 11; /* "" */
|
||||
}
|
||||
/* Now define some things here to avoid #ifdefs in the code below.
|
||||
* These should optimize out of the if conditions below. */
|
||||
|
||||
+1
-1
@@ -37,7 +37,7 @@ static int printf_full(unsigned int id, const char *arg, const char prefix)
|
||||
}
|
||||
|
||||
int id_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int id_main(int argc, char **argv)
|
||||
int id_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
struct passwd *p;
|
||||
uid_t uid;
|
||||
|
||||
@@ -11,6 +11,6 @@ typedef int (*stat_func)(const char *fn, struct stat *ps);
|
||||
int cp_mv_stat2(const char *fn, struct stat *fn_stat, stat_func sf);
|
||||
int cp_mv_stat(const char *fn, struct stat *fn_stat);
|
||||
|
||||
mode_t getopt_mk_fifo_nod(int argc, char **argv);
|
||||
mode_t getopt_mk_fifo_nod(char **argv);
|
||||
|
||||
#endif
|
||||
@@ -27,6 +27,12 @@ int cp_mv_stat2(const char *fn, struct stat *fn_stat, stat_func sf)
|
||||
{
|
||||
if (sf(fn, fn_stat) < 0) {
|
||||
if (errno != ENOENT) {
|
||||
#if ENABLE_FEATURE_VERBOSE_CP_MESSAGE
|
||||
if (errno == ENOTDIR) {
|
||||
bb_error_msg("cannot stat '%s': Path has non-directory component", fn);
|
||||
return -1;
|
||||
}
|
||||
#endif
|
||||
bb_perror_msg("cannot stat '%s'", fn);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
#include "libbb.h"
|
||||
#include "coreutils.h"
|
||||
|
||||
mode_t getopt_mk_fifo_nod(int argc, char **argv)
|
||||
mode_t getopt_mk_fifo_nod(char **argv)
|
||||
{
|
||||
mode_t mode = 0666;
|
||||
char *smode = NULL;
|
||||
|
||||
+2
-7
@@ -799,8 +799,6 @@ int ls_main(int argc, char **argv)
|
||||
int ac;
|
||||
int i;
|
||||
char **av;
|
||||
USE_FEATURE_AUTOWIDTH(char *tabstops_str = NULL;)
|
||||
USE_FEATURE_AUTOWIDTH(char *terminal_width_str = NULL;)
|
||||
USE_FEATURE_LS_COLOR(char *color_opt;)
|
||||
|
||||
#if ENABLE_FEATURE_LS_TIMESTAMPS
|
||||
@@ -820,12 +818,9 @@ int ls_main(int argc, char **argv)
|
||||
/* process options */
|
||||
USE_FEATURE_LS_COLOR(applet_long_options = ls_color_opt;)
|
||||
#if ENABLE_FEATURE_AUTOWIDTH
|
||||
opt = getopt32(argv, ls_options, &tabstops_str, &terminal_width_str
|
||||
opt_complementary = "T+:w+"; /* -T N, -w N */
|
||||
opt = getopt32(argv, ls_options, &tabstops, &terminal_width
|
||||
USE_FEATURE_LS_COLOR(, &color_opt));
|
||||
if (tabstops_str)
|
||||
tabstops = xatou(tabstops_str);
|
||||
if (terminal_width_str)
|
||||
terminal_width = xatou(terminal_width_str);
|
||||
#else
|
||||
opt = getopt32(argv, ls_options USE_FEATURE_LS_COLOR(, &color_opt));
|
||||
#endif
|
||||
|
||||
+14
-23
@@ -36,12 +36,9 @@ static uint8_t *hash_file(const char *filename, hash_algo_t hash_algo)
|
||||
void (*update)(const void*, size_t, void*);
|
||||
void (*final)(void*, void*);
|
||||
|
||||
src_fd = STDIN_FILENO;
|
||||
if (NOT_LONE_DASH(filename)) {
|
||||
src_fd = open_or_warn(filename, O_RDONLY);
|
||||
if (src_fd < 0) {
|
||||
return NULL;
|
||||
}
|
||||
src_fd = open_or_warn_stdin(filename);
|
||||
if (src_fd < 0) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* figure specific hash algorithims */
|
||||
@@ -78,7 +75,7 @@ static uint8_t *hash_file(const char *filename, hash_algo_t hash_algo)
|
||||
}
|
||||
|
||||
int md5_sha1_sum_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int md5_sha1_sum_main(int argc, char **argv)
|
||||
int md5_sha1_sum_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
int return_value = EXIT_SUCCESS;
|
||||
uint8_t *hash_value;
|
||||
@@ -90,6 +87,10 @@ int md5_sha1_sum_main(int argc, char **argv)
|
||||
if (ENABLE_FEATURE_MD5_SHA1_SUM_CHECK)
|
||||
flags = getopt32(argv, "scw");
|
||||
else optind = 1;
|
||||
argv += optind;
|
||||
//argc -= optind;
|
||||
if (!*argv)
|
||||
*--argv = (char*)"-";
|
||||
|
||||
if (ENABLE_FEATURE_MD5_SHA1_SUM_CHECK && !(flags & FLAG_CHECK)) {
|
||||
if (flags & FLAG_SILENT) {
|
||||
@@ -101,26 +102,18 @@ int md5_sha1_sum_main(int argc, char **argv)
|
||||
}
|
||||
}
|
||||
|
||||
if (argc == optind) {
|
||||
argv[argc++] = (char*)"-";
|
||||
}
|
||||
|
||||
if (ENABLE_FEATURE_MD5_SHA1_SUM_CHECK && (flags & FLAG_CHECK)) {
|
||||
FILE *pre_computed_stream;
|
||||
int count_total = 0;
|
||||
int count_failed = 0;
|
||||
char *file_ptr = argv[optind];
|
||||
char *line;
|
||||
|
||||
if (optind + 1 != argc) {
|
||||
if (argv[1]) {
|
||||
bb_error_msg_and_die
|
||||
("only one argument may be specified when using -c");
|
||||
}
|
||||
|
||||
pre_computed_stream = stdin;
|
||||
if (NOT_LONE_DASH(file_ptr)) {
|
||||
pre_computed_stream = xfopen(file_ptr, "r");
|
||||
}
|
||||
pre_computed_stream = xfopen_stdin(argv[0]);
|
||||
|
||||
while ((line = xmalloc_getline(pre_computed_stream)) != NULL) {
|
||||
char *filename_ptr;
|
||||
@@ -168,17 +161,15 @@ int md5_sha1_sum_main(int argc, char **argv)
|
||||
}
|
||||
*/
|
||||
} else {
|
||||
while (optind < argc) {
|
||||
char *file_ptr = argv[optind++];
|
||||
|
||||
hash_value = hash_file(file_ptr, hash_algo);
|
||||
do {
|
||||
hash_value = hash_file(*argv, hash_algo);
|
||||
if (hash_value == NULL) {
|
||||
return_value = EXIT_FAILURE;
|
||||
} else {
|
||||
printf("%s %s\n", hash_value, file_ptr);
|
||||
printf("%s %s\n", hash_value, *argv);
|
||||
free(hash_value);
|
||||
}
|
||||
}
|
||||
} while (*++argv);
|
||||
}
|
||||
return return_value;
|
||||
}
|
||||
+2
-2
@@ -14,12 +14,12 @@
|
||||
#include "libcoreutils/coreutils.h"
|
||||
|
||||
int mkfifo_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int mkfifo_main(int argc, char **argv)
|
||||
int mkfifo_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
mode_t mode;
|
||||
int retval = EXIT_SUCCESS;
|
||||
|
||||
mode = getopt_mk_fifo_nod(argc, argv);
|
||||
mode = getopt_mk_fifo_nod(argv);
|
||||
|
||||
argv += optind;
|
||||
if (!*argv) {
|
||||
|
||||
+21
-15
@@ -24,27 +24,33 @@ int mknod_main(int argc, char **argv)
|
||||
dev_t dev;
|
||||
const char *name;
|
||||
|
||||
mode = getopt_mk_fifo_nod(argc, argv);
|
||||
mode = getopt_mk_fifo_nod(argv);
|
||||
argv += optind;
|
||||
argc -= optind;
|
||||
|
||||
if ((argc >= 2) && ((name = strchr(modes_chars, argv[1][0])) != NULL)) {
|
||||
mode |= modes_cubp[(int)(name[4])];
|
||||
if (argc >= 2) {
|
||||
name = strchr(modes_chars, argv[1][0]);
|
||||
if (name != NULL) {
|
||||
mode |= modes_cubp[(int)(name[4])];
|
||||
|
||||
dev = 0;
|
||||
if ((*name != 'p') && ((argc -= 2) == 2)) {
|
||||
/* Autodetect what the system supports; these macros should
|
||||
* optimize out to two constants. */
|
||||
dev = makedev(xatoul_range(argv[2], 0, major(UINT_MAX)),
|
||||
xatoul_range(argv[3], 0, minor(UINT_MAX)));
|
||||
}
|
||||
dev = 0;
|
||||
if (*name != 'p') {
|
||||
argc -= 2;
|
||||
if (argc == 2) {
|
||||
/* Autodetect what the system supports; these macros should
|
||||
* optimize out to two constants. */
|
||||
dev = makedev(xatoul_range(argv[2], 0, major(UINT_MAX)),
|
||||
xatoul_range(argv[3], 0, minor(UINT_MAX)));
|
||||
}
|
||||
}
|
||||
|
||||
if (argc == 2) {
|
||||
name = *argv;
|
||||
if (mknod(name, mode, dev) == 0) {
|
||||
return EXIT_SUCCESS;
|
||||
if (argc == 2) {
|
||||
name = *argv;
|
||||
if (mknod(name, mode, dev) == 0) {
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
bb_simple_perror_msg_and_die(name);
|
||||
}
|
||||
bb_simple_perror_msg_and_die(name);
|
||||
}
|
||||
}
|
||||
bb_show_usage();
|
||||
|
||||
+1
-1
@@ -58,7 +58,7 @@ int mv_main(int argc, char **argv)
|
||||
if (argc == 2) {
|
||||
dest_exists = cp_mv_stat(last, &dest_stat);
|
||||
if (dest_exists < 0) {
|
||||
return 1;
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
if (!(dest_exists & 2)) {
|
||||
|
||||
+33
-15
@@ -12,21 +12,41 @@
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
/* Compat info: nohup (GNU coreutils 6.8) does this:
|
||||
# nohup true
|
||||
nohup: ignoring input and appending output to `nohup.out'
|
||||
# nohup true 1>/dev/null
|
||||
nohup: ignoring input and redirecting stderr to stdout
|
||||
# nohup true 2>zz
|
||||
# cat zz
|
||||
nohup: ignoring input and appending output to `nohup.out'
|
||||
# nohup true 2>zz 1>/dev/null
|
||||
# cat zz
|
||||
nohup: ignoring input
|
||||
# nohup true </dev/null 1>/dev/null
|
||||
nohup: redirecting stderr to stdout
|
||||
# nohup true </dev/null 2>zz 1>/dev/null
|
||||
# cat zz
|
||||
(nothing)
|
||||
#
|
||||
*/
|
||||
|
||||
int nohup_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int nohup_main(int argc, char **argv)
|
||||
{
|
||||
int nullfd;
|
||||
const char *nohupout;
|
||||
char *home = NULL;
|
||||
char *home;
|
||||
|
||||
xfunc_error_retval = 127;
|
||||
|
||||
if (argc < 2) bb_show_usage();
|
||||
|
||||
nullfd = xopen(bb_dev_null, O_WRONLY|O_APPEND);
|
||||
/* If stdin is a tty, detach from it. */
|
||||
if (isatty(STDIN_FILENO))
|
||||
dup2(nullfd, STDIN_FILENO);
|
||||
if (isatty(STDIN_FILENO)) {
|
||||
/* bb_error_msg("ignoring input"); */
|
||||
close(STDIN_FILENO);
|
||||
xopen(bb_dev_null, O_RDONLY); /* will be fd 0 (STDIN_FILENO) */
|
||||
}
|
||||
|
||||
nohupout = "nohup.out";
|
||||
/* Redirect stdout to nohup.out, either in "." or in "$HOME". */
|
||||
@@ -37,24 +57,22 @@ int nohup_main(int argc, char **argv)
|
||||
if (home) {
|
||||
nohupout = concat_path_file(home, nohupout);
|
||||
xopen3(nohupout, O_CREAT|O_WRONLY|O_APPEND, S_IRUSR|S_IWUSR);
|
||||
} else {
|
||||
xopen(bb_dev_null, O_RDONLY); /* will be fd 1 */
|
||||
}
|
||||
}
|
||||
} else dup2(nullfd, STDOUT_FILENO);
|
||||
bb_error_msg("appending output to %s", nohupout);
|
||||
}
|
||||
|
||||
/* If we have a tty on stderr, announce filename and redirect to stdout.
|
||||
* Else redirect to /dev/null.
|
||||
*/
|
||||
/* If we have a tty on stderr, redirect to stdout. */
|
||||
if (isatty(STDERR_FILENO)) {
|
||||
bb_error_msg("appending to %s", nohupout);
|
||||
/* if (stdout_wasnt_a_tty)
|
||||
bb_error_msg("redirecting stderr to stdout"); */
|
||||
dup2(STDOUT_FILENO, STDERR_FILENO);
|
||||
} else dup2(nullfd, STDERR_FILENO);
|
||||
}
|
||||
|
||||
if (nullfd > 2)
|
||||
close(nullfd);
|
||||
signal(SIGHUP, SIG_IGN);
|
||||
|
||||
BB_EXECVP(argv[1], argv+1);
|
||||
if (ENABLE_FEATURE_CLEAN_UP && home)
|
||||
free((char*)nohupout);
|
||||
bb_simple_perror_msg_and_die(argv[1]);
|
||||
}
|
||||
+45
-65
@@ -17,7 +17,7 @@
|
||||
|
||||
/* Written by Jim Meyering. */
|
||||
|
||||
/* Busyboxed by Denis Vlasenko
|
||||
/* Busyboxed by Denys Vlasenko
|
||||
|
||||
Based on od.c from coreutils-5.2.1
|
||||
Top bloat sources:
|
||||
@@ -181,37 +181,23 @@ static void (*format_address)(off_t, char);
|
||||
/* The difference between the old-style pseudo starting address and
|
||||
the number of bytes to skip. */
|
||||
static off_t pseudo_offset;
|
||||
/* The number of input bytes to skip before formatting and writing. */
|
||||
static off_t n_bytes_to_skip;
|
||||
/* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
|
||||
input is formatted. */
|
||||
/* The maximum number of bytes that will be formatted. */
|
||||
static off_t max_bytes_to_format;
|
||||
/* The offset of the first byte after the last byte to be formatted. */
|
||||
static off_t end_offset;
|
||||
|
||||
/* The number of input bytes formatted per output line. It must be
|
||||
a multiple of the least common multiple of the sizes associated with
|
||||
the specified output types. It should be as large as possible, but
|
||||
no larger than 16 -- unless specified with the -w option. */
|
||||
static size_t bytes_per_block;
|
||||
|
||||
/* Human-readable representation of *file_list (for error messages).
|
||||
It differs from *file_list only when *file_list is "-". */
|
||||
static char const *input_filename;
|
||||
static unsigned bytes_per_block = 32; /* have to use unsigned, not size_t */
|
||||
|
||||
/* A NULL-terminated list of the file-arguments from the command line. */
|
||||
static char const *const *file_list;
|
||||
|
||||
/* Initializer for file_list if no file-arguments
|
||||
were specified on the command line. */
|
||||
static char const *const default_file_list[] = { "-", NULL };
|
||||
static const char *const *file_list;
|
||||
|
||||
/* The input stream associated with the current file. */
|
||||
static FILE *in_stream;
|
||||
|
||||
#define MAX_INTEGRAL_TYPE_SIZE sizeof(ulonglong_t)
|
||||
static unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1] ALIGN1 = {
|
||||
static const unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1] ALIGN1 = {
|
||||
[sizeof(char)] = CHAR,
|
||||
#if USHRT_MAX != UCHAR_MAX
|
||||
[sizeof(short)] = SHORT,
|
||||
@@ -228,7 +214,7 @@ static unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1] ALIGN1 = {
|
||||
};
|
||||
|
||||
#define MAX_FP_TYPE_SIZE sizeof(longdouble_t)
|
||||
static unsigned char fp_type_size[MAX_FP_TYPE_SIZE + 1] ALIGN1 = {
|
||||
static const unsigned char fp_type_size[MAX_FP_TYPE_SIZE + 1] ALIGN1 = {
|
||||
/* gcc seems to allow repeated indexes. Last one stays */
|
||||
[sizeof(longdouble_t)] = FLOAT_LONG_DOUBLE,
|
||||
[sizeof(double)] = FLOAT_DOUBLE,
|
||||
@@ -374,7 +360,7 @@ print_long_double(size_t n_bytes, const char *block, const char *fmt_string)
|
||||
}
|
||||
|
||||
/* print_[named]_ascii are optimized for speed.
|
||||
* Remember, someday you may want to pump gigabytes thru this thing.
|
||||
* Remember, someday you may want to pump gigabytes through this thing.
|
||||
* Saving a dozen of .text bytes here is counter-productive */
|
||||
|
||||
static void
|
||||
@@ -481,14 +467,10 @@ static void
|
||||
open_next_file(void)
|
||||
{
|
||||
while (1) {
|
||||
input_filename = *file_list;
|
||||
if (!input_filename)
|
||||
if (!*file_list)
|
||||
return;
|
||||
file_list++;
|
||||
in_stream = fopen_or_warn_stdin(input_filename);
|
||||
in_stream = fopen_or_warn_stdin(*file_list++);
|
||||
if (in_stream) {
|
||||
if (in_stream == stdin)
|
||||
input_filename = bb_msg_standard_input;
|
||||
break;
|
||||
}
|
||||
ioerror = 1;
|
||||
@@ -510,7 +492,10 @@ check_and_close(void)
|
||||
{
|
||||
if (in_stream) {
|
||||
if (ferror(in_stream)) {
|
||||
bb_error_msg("%s: read error", input_filename);
|
||||
bb_error_msg("%s: read error", (in_stream == stdin)
|
||||
? bb_msg_standard_input
|
||||
: file_list[-1]
|
||||
);
|
||||
ioerror = 1;
|
||||
}
|
||||
fclose_if_not_stdin(in_stream);
|
||||
@@ -738,7 +723,7 @@ decode_one_format(const char *s_orig, const char *s, const char **next,
|
||||
|
||||
/* Decode the modern od format string S. Append the decoded
|
||||
representation to the global array SPEC, reallocating SPEC if
|
||||
necessary. Return zero if S is valid, nonzero otherwise. */
|
||||
necessary. */
|
||||
|
||||
static void
|
||||
decode_format_string(const char *s)
|
||||
@@ -791,21 +776,22 @@ skip(off_t n_skip)
|
||||
as large as the size of the current file, we can
|
||||
decrement n_skip and go on to the next file. */
|
||||
if (fstat(fileno(in_stream), &file_stats) == 0
|
||||
&& S_ISREG(file_stats.st_mode) && file_stats.st_size >= 0
|
||||
&& S_ISREG(file_stats.st_mode) && file_stats.st_size > 0
|
||||
) {
|
||||
if (file_stats.st_size < n_skip) {
|
||||
n_skip -= file_stats.st_size;
|
||||
/* take check&close / open_next route */
|
||||
/* take "check & close / open_next" route */
|
||||
} else {
|
||||
if (fseeko(in_stream, n_skip, SEEK_CUR) != 0)
|
||||
ioerror = 1;
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
/* If it's not a regular file with nonnegative size,
|
||||
/* If it's not a regular file with positive size,
|
||||
position the file pointer by reading. */
|
||||
char buf[BUFSIZ];
|
||||
size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
|
||||
char buf[1024];
|
||||
size_t n_bytes_to_read = 1024;
|
||||
size_t n_bytes_read;
|
||||
|
||||
while (n_skip > 0) {
|
||||
if (n_skip < n_bytes_to_read)
|
||||
@@ -1014,23 +1000,18 @@ parse_old_offset(const char *s, off_t *offset)
|
||||
spec, extend the input block with zero bytes until its length is a
|
||||
multiple of all format spec sizes. Write the final block. Finally,
|
||||
write on a line by itself the offset of the byte after the last byte
|
||||
read. Accumulate return values from calls to read_block and
|
||||
check_and_close, and if any was nonzero, return nonzero.
|
||||
Otherwise, return zero. */
|
||||
read. */
|
||||
|
||||
static void
|
||||
dump(void)
|
||||
dump(off_t current_offset, off_t end_offset)
|
||||
{
|
||||
char *block[2];
|
||||
off_t current_offset;
|
||||
int idx;
|
||||
size_t n_bytes_read;
|
||||
|
||||
block[0] = xmalloc(2*bytes_per_block);
|
||||
block[1] = block[0] + bytes_per_block;
|
||||
|
||||
current_offset = n_bytes_to_skip;
|
||||
|
||||
idx = 0;
|
||||
if (limit_bytes_to_format) {
|
||||
while (1) {
|
||||
@@ -1095,8 +1076,7 @@ dump(void)
|
||||
and INPUT_FILENAME so they correspond to the next file in the list.
|
||||
Then try to read a byte from the newly opened file. Repeat if
|
||||
necessary until EOF is reached for the last file in FILE_LIST, then
|
||||
set *C to EOF and return. Subsequent calls do likewise. The return
|
||||
value is nonzero if any errors occured, zero otherwise. */
|
||||
set *C to EOF and return. Subsequent calls do likewise. */
|
||||
|
||||
static void
|
||||
read_char(int *c)
|
||||
@@ -1129,15 +1109,13 @@ read_char(int *c)
|
||||
A string constant is a run of at least 'string_min' ASCII
|
||||
graphic (or formatting) characters terminated by a null.
|
||||
Based on a function written by Richard Stallman for a
|
||||
traditional version of od. Return nonzero if an error
|
||||
occurs. Otherwise, return zero. */
|
||||
traditional version of od. */
|
||||
|
||||
static void
|
||||
dump_strings(void)
|
||||
dump_strings(off_t address, off_t end_offset)
|
||||
{
|
||||
size_t bufsize = MAX(100, string_min);
|
||||
char *buf = xmalloc(bufsize);
|
||||
off_t address = n_bytes_to_skip;
|
||||
|
||||
while (1) {
|
||||
size_t i;
|
||||
@@ -1169,7 +1147,7 @@ dump_strings(void)
|
||||
if (i < string_min) /* Too short! */
|
||||
goto tryline;
|
||||
|
||||
/* If we get here, the string is all printable and null-terminated,
|
||||
/* If we get here, the string is all printable and NUL-terminated,
|
||||
* so print it. It is all in 'buf' and 'i' is its length. */
|
||||
buf[i] = 0;
|
||||
format_address(address - i - 1, ' ');
|
||||
@@ -1183,7 +1161,7 @@ dump_strings(void)
|
||||
case '\r': fputs("\\r", stdout); break;
|
||||
case '\t': fputs("\\t", stdout); break;
|
||||
case '\v': fputs("\\v", stdout); break;
|
||||
default: bb_putchar(c);
|
||||
default: putchar(c);
|
||||
}
|
||||
}
|
||||
putchar('\n');
|
||||
@@ -1205,11 +1183,6 @@ int od_main(int argc, char **argv)
|
||||
{ "m", 1024*1024 },
|
||||
{ }
|
||||
};
|
||||
unsigned opt;
|
||||
int l_c_m;
|
||||
/* The old-style 'pseudo starting address' to be printed in parentheses
|
||||
after any true address. */
|
||||
off_t pseudo_start = 0; // only for gcc
|
||||
enum {
|
||||
OPT_A = 1 << 0,
|
||||
OPT_N = 1 << 1,
|
||||
@@ -1244,8 +1217,18 @@ int od_main(int argc, char **argv)
|
||||
;
|
||||
#endif
|
||||
char *str_A, *str_N, *str_j, *str_S;
|
||||
char *str_w = NULL;
|
||||
llist_t *lst_t = NULL;
|
||||
unsigned opt;
|
||||
int l_c_m;
|
||||
/* The old-style 'pseudo starting address' to be printed in parentheses
|
||||
after any true address. */
|
||||
off_t pseudo_start = pseudo_start; // for gcc
|
||||
/* The number of input bytes to skip before formatting and writing. */
|
||||
off_t n_bytes_to_skip = 0;
|
||||
/* The offset of the first byte after the last byte to be formatted. */
|
||||
off_t end_offset = 0;
|
||||
/* The maximum number of bytes that will be formatted. */
|
||||
off_t max_bytes_to_format = 0;
|
||||
|
||||
spec = NULL;
|
||||
format_address = format_address_std;
|
||||
@@ -1254,7 +1237,7 @@ int od_main(int argc, char **argv)
|
||||
/* flag_dump_strings = 0; - already is */
|
||||
|
||||
/* Parse command line */
|
||||
opt_complementary = "t::"; // list
|
||||
opt_complementary = "w+:t::"; /* -w N, -t is a list */
|
||||
#if ENABLE_GETOPT_LONG
|
||||
applet_long_options = od_longopts;
|
||||
#endif
|
||||
@@ -1263,7 +1246,7 @@ int od_main(int argc, char **argv)
|
||||
// -S was -s and also had optional parameter
|
||||
// but in coreutils 6.3 it was renamed and now has
|
||||
// _mandatory_ parameter
|
||||
&str_A, &str_N, &str_j, &lst_t, &str_S, &str_w);
|
||||
&str_A, &str_N, &str_j, &lst_t, &str_S, &bytes_per_block);
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
if (opt & OPT_A) {
|
||||
@@ -1399,7 +1382,7 @@ int od_main(int argc, char **argv)
|
||||
/* If no files were listed on the command line,
|
||||
set the global pointer FILE_LIST so that it
|
||||
references the null-terminated list of one name: "-". */
|
||||
file_list = default_file_list;
|
||||
file_list = bb_argv_dash;
|
||||
if (argc > 0) {
|
||||
/* Set the global pointer FILE_LIST so that it
|
||||
references the first file-argument on the command-line. */
|
||||
@@ -1411,7 +1394,7 @@ int od_main(int argc, char **argv)
|
||||
/* skip over any unwanted header bytes */
|
||||
skip(n_bytes_to_skip);
|
||||
if (!in_stream)
|
||||
return 1;
|
||||
return EXIT_FAILURE;
|
||||
|
||||
pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
|
||||
|
||||
@@ -1419,12 +1402,9 @@ int od_main(int argc, char **argv)
|
||||
l_c_m = get_lcm();
|
||||
|
||||
if (opt & OPT_w) { /* -w: width */
|
||||
bytes_per_block = 32;
|
||||
if (str_w)
|
||||
bytes_per_block = xatou(str_w);
|
||||
if (!bytes_per_block || bytes_per_block % l_c_m != 0) {
|
||||
bb_error_msg("warning: invalid width %zu; using %d instead",
|
||||
bytes_per_block, l_c_m);
|
||||
bb_error_msg("warning: invalid width %u; using %d instead",
|
||||
(unsigned)bytes_per_block, l_c_m);
|
||||
bytes_per_block = l_c_m;
|
||||
}
|
||||
} else {
|
||||
@@ -1441,9 +1421,9 @@ int od_main(int argc, char **argv)
|
||||
#endif
|
||||
|
||||
if (flag_dump_strings)
|
||||
dump_strings();
|
||||
dump_strings(n_bytes_to_skip, end_offset);
|
||||
else
|
||||
dump();
|
||||
dump(n_bytes_to_skip, end_offset);
|
||||
|
||||
if (fclose(stdin) == EOF)
|
||||
bb_perror_msg_and_die(bb_msg_standard_input);
|
||||
|
||||
@@ -9,13 +9,12 @@
|
||||
*/
|
||||
|
||||
#include "libbb.h"
|
||||
extern char **environ;
|
||||
|
||||
int printenv_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int printenv_main(int argc, char **argv)
|
||||
int printenv_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
/* no variables specified, show whole env */
|
||||
if (argc == 1) {
|
||||
if (!argv[1]) {
|
||||
int e = 0;
|
||||
while (environ[e])
|
||||
puts(environ[e++]);
|
||||
|
||||
+1
-1
@@ -12,7 +12,7 @@
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
int pwd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int pwd_main(int argc, char **argv)
|
||||
int pwd_main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
|
||||
{
|
||||
char *buf;
|
||||
|
||||
|
||||
@@ -8,14 +8,14 @@
|
||||
*/
|
||||
|
||||
#include <getopt.h>
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
int readlink_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int readlink_main(int argc, char **argv)
|
||||
int readlink_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
char *buf;
|
||||
char *fname;
|
||||
char pathbuf[PATH_MAX];
|
||||
|
||||
USE_FEATURE_READLINK_FOLLOW(
|
||||
unsigned opt;
|
||||
@@ -34,7 +34,7 @@ int readlink_main(int argc, char **argv)
|
||||
logmode = LOGMODE_NONE;
|
||||
|
||||
if (opt) {
|
||||
buf = realpath(fname, bb_common_bufsiz1);
|
||||
buf = realpath(fname, pathbuf);
|
||||
} else {
|
||||
buf = xmalloc_readlink_or_warn(fname);
|
||||
}
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
#include "libbb.h"
|
||||
|
||||
int realpath_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int realpath_main(int argc, char **argv)
|
||||
int realpath_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
int retval = EXIT_SUCCESS;
|
||||
|
||||
@@ -25,19 +25,18 @@ int realpath_main(int argc, char **argv)
|
||||
# define resolved_path_MUST_FREE 0
|
||||
#endif
|
||||
|
||||
if (--argc == 0) {
|
||||
if (!*++argv) {
|
||||
bb_show_usage();
|
||||
}
|
||||
|
||||
do {
|
||||
argv++;
|
||||
if (realpath(*argv, resolved_path) != NULL) {
|
||||
puts(resolved_path);
|
||||
} else {
|
||||
retval = EXIT_FAILURE;
|
||||
bb_simple_perror_msg(*argv);
|
||||
}
|
||||
} while (--argc);
|
||||
} while (*++argv);
|
||||
|
||||
#if ENABLE_FEATURE_CLEAN_UP && resolved_path_MUST_FREE
|
||||
RELEASE_CONFIG_BUFFER(resolved_path);
|
||||
|
||||
+1
-1
@@ -20,7 +20,7 @@
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
int rm_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int rm_main(int argc, char **argv)
|
||||
int rm_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
int status = 0;
|
||||
int flags = 0;
|
||||
|
||||
+22
-13
@@ -10,20 +10,30 @@
|
||||
/* BB_AUDIT SUSv3 compliant */
|
||||
/* http://www.opengroup.org/onlinepubs/007904975/utilities/rmdir.html */
|
||||
|
||||
#include <libgen.h>
|
||||
#include "libbb.h"
|
||||
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
|
||||
#define PARENTS 0x01
|
||||
#define IGNORE_NON_EMPTY 0x02
|
||||
|
||||
int rmdir_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int rmdir_main(int argc, char **argv)
|
||||
int rmdir_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
int status = EXIT_SUCCESS;
|
||||
int flags;
|
||||
int do_dot;
|
||||
char *path;
|
||||
|
||||
#if ENABLE_FEATURE_RMDIR_LONG_OPTIONS
|
||||
static const char rmdir_longopts[] ALIGN1 =
|
||||
"parents\0" No_argument "p"
|
||||
/* Debian etch: many packages fail to be purged or installed
|
||||
* because they desperately want this option: */
|
||||
"ignore-fail-on-non-empty\0" No_argument "\xff"
|
||||
;
|
||||
applet_long_options = rmdir_longopts;
|
||||
#endif
|
||||
flags = getopt32(argv, "p");
|
||||
argv += optind;
|
||||
|
||||
@@ -34,27 +44,26 @@ int rmdir_main(int argc, char **argv)
|
||||
do {
|
||||
path = *argv;
|
||||
|
||||
/* Record if the first char was a '.' so we can use dirname later. */
|
||||
do_dot = (*path == '.');
|
||||
|
||||
while (1) {
|
||||
if (rmdir(path) < 0) {
|
||||
#if ENABLE_FEATURE_RMDIR_LONG_OPTIONS
|
||||
if ((flags & IGNORE_NON_EMPTY) && errno == ENOTEMPTY)
|
||||
break;
|
||||
#endif
|
||||
bb_perror_msg("'%s'", path); /* Match gnu rmdir msg. */
|
||||
status = EXIT_FAILURE;
|
||||
} else if (flags) {
|
||||
/* Note: path was not empty or null since rmdir succeeded. */
|
||||
} else if (flags & PARENTS) {
|
||||
/* Note: path was not "" since rmdir succeeded. */
|
||||
path = dirname(path);
|
||||
/* Path is now just the parent component. Note that dirname
|
||||
* returns "." if there are no parents. We must distinguish
|
||||
* this from the case of the original path starting with '.'.
|
||||
/* Path is now just the parent component. Dirname
|
||||
* returns "." if there are no parents.
|
||||
*/
|
||||
if (do_dot || (*path != '.') || path[1]) {
|
||||
if (NOT_LONE_CHAR(path, '.')) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
} while (*++argv);
|
||||
|
||||
return status;
|
||||
|
||||
+6
-11
@@ -34,17 +34,16 @@ static const struct suffix_mult sfx[] = {
|
||||
#endif
|
||||
|
||||
int sleep_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int sleep_main(int argc, char **argv)
|
||||
int sleep_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
unsigned duration;
|
||||
|
||||
++argv;
|
||||
if (!*argv)
|
||||
bb_show_usage();
|
||||
|
||||
#if ENABLE_FEATURE_FANCY_SLEEP
|
||||
|
||||
if (argc < 2) {
|
||||
bb_show_usage();
|
||||
}
|
||||
|
||||
++argv;
|
||||
duration = 0;
|
||||
do {
|
||||
duration += xatoul_range_sfx(*argv, 0, UINT_MAX-duration, sfx);
|
||||
@@ -52,11 +51,7 @@ int sleep_main(int argc, char **argv)
|
||||
|
||||
#else /* FEATURE_FANCY_SLEEP */
|
||||
|
||||
if (argc != 2) {
|
||||
bb_show_usage();
|
||||
}
|
||||
|
||||
duration = xatou(argv[1]);
|
||||
duration = xatou(*argv);
|
||||
|
||||
#endif /* FEATURE_FANCY_SLEEP */
|
||||
|
||||
|
||||
+16
-11
@@ -32,7 +32,7 @@ enum {
|
||||
FLAG_u = 8, /* Unique */
|
||||
FLAG_c = 0x10, /* Check: no output, exit(!ordered) */
|
||||
FLAG_s = 0x20, /* Stable sort, no ascii fallback at end */
|
||||
FLAG_z = 0x40, /* Input is null terminated, not \n */
|
||||
FLAG_z = 0x40, /* Input and output is NUL terminated, not \n */
|
||||
/* These can be applied to search keys, the previous four can't */
|
||||
FLAG_b = 0x80, /* Ignore leading blanks */
|
||||
FLAG_r = 0x100, /* Reverse */
|
||||
@@ -275,7 +275,7 @@ static unsigned str2u(char **str)
|
||||
#endif
|
||||
|
||||
int sort_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int sort_main(int argc, char **argv)
|
||||
int sort_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
FILE *fp, *outfile = stdout;
|
||||
char *line, **lines = NULL;
|
||||
@@ -351,10 +351,13 @@ int sort_main(int argc, char **argv)
|
||||
if (option_mask32 & FLAG_b) option_mask32 |= FLAG_bb;
|
||||
|
||||
/* Open input files and read data */
|
||||
for (i = argv[optind] ? optind : optind-1; argv[i]; i++) {
|
||||
fp = stdin;
|
||||
if (i >= optind && NOT_LONE_DASH(argv[i]))
|
||||
fp = xfopen(argv[i], "r");
|
||||
argv += optind;
|
||||
if (!*argv)
|
||||
*--argv = (char*)"-";
|
||||
do {
|
||||
/* coreutils 6.9 compat: abort on first open error,
|
||||
* do not continue to next file: */
|
||||
fp = xfopen_stdin(*argv);
|
||||
for (;;) {
|
||||
line = GET_LINE(fp);
|
||||
if (!line) break;
|
||||
@@ -362,8 +365,9 @@ int sort_main(int argc, char **argv)
|
||||
lines = xrealloc(lines, sizeof(char *) * (linecount + 64));
|
||||
lines[linecount++] = line;
|
||||
}
|
||||
fclose(fp);
|
||||
}
|
||||
fclose_if_not_stdin(fp);
|
||||
} while (*++argv);
|
||||
|
||||
#if ENABLE_FEATURE_SORT_BIG
|
||||
/* if no key, perform alphabetic sort */
|
||||
if (!key_list)
|
||||
@@ -374,9 +378,9 @@ int sort_main(int argc, char **argv)
|
||||
for (i = 1; i < linecount; i++)
|
||||
if (compare_keys(&lines[i-1], &lines[i]) > j) {
|
||||
fprintf(stderr, "Check line %d\n", i);
|
||||
return 1;
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
return 0;
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
#endif
|
||||
/* Perform the actual sort */
|
||||
@@ -396,8 +400,9 @@ int sort_main(int argc, char **argv)
|
||||
if (linecount) linecount = flag+1;
|
||||
}
|
||||
/* Print it */
|
||||
flag = (option_mask32 & FLAG_z) ? '\0' : '\n';
|
||||
for (i = 0; i < linecount; i++)
|
||||
fprintf(outfile, "%s\n", lines[i]);
|
||||
fprintf(outfile, "%s%c", lines[i], flag);
|
||||
|
||||
fflush_stdout_and_exit(EXIT_SUCCESS);
|
||||
}
|
||||
+7
-9
@@ -56,7 +56,7 @@ enum { READ_BUFFER_SIZE = COMMON_BUFSIZE - 1 };
|
||||
#define SPLIT_OPT_a (1<<2)
|
||||
|
||||
int split_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int split_main(int argc, char **argv)
|
||||
int split_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
unsigned suffix_len = 2;
|
||||
char *pfx;
|
||||
@@ -68,15 +68,13 @@ int split_main(int argc, char **argv)
|
||||
ssize_t bytes_read, to_write;
|
||||
char *src;
|
||||
|
||||
opt_complementary = "?2";
|
||||
opt = getopt32(argv, "l:b:a:", &count_p, &count_p, &sfx);
|
||||
opt_complementary = "?2:a+"; /* max 2 args; -a N */
|
||||
opt = getopt32(argv, "l:b:a:", &count_p, &count_p, &suffix_len);
|
||||
|
||||
if (opt & SPLIT_OPT_l)
|
||||
cnt = xatoul(count_p);
|
||||
if (opt & SPLIT_OPT_b)
|
||||
cnt = xatoul_sfx(count_p, split_suffices);
|
||||
if (opt & SPLIT_OPT_a)
|
||||
suffix_len = xatou(sfx);
|
||||
cnt = XATOOFF(count_p);
|
||||
if (opt & SPLIT_OPT_b) // FIXME: also needs XATOOFF
|
||||
cnt = xatoull_sfx(count_p, split_suffices);
|
||||
sfx = "x";
|
||||
|
||||
argv += optind;
|
||||
@@ -137,5 +135,5 @@ int split_main(int argc, char **argv)
|
||||
src += to_write;
|
||||
} while (bytes_read);
|
||||
}
|
||||
return 0;
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
+18
-3
@@ -21,6 +21,12 @@
|
||||
#define OPT_DEREFERENCE (1 << 2)
|
||||
#define OPT_SELINUX (1 << 3)
|
||||
|
||||
#if ENABLE_FEATURE_STAT_FORMAT
|
||||
typedef bool (*statfunc_ptr)(const char *, const char *);
|
||||
#else
|
||||
typedef bool (*statfunc_ptr)(const char *);
|
||||
#endif
|
||||
|
||||
static const char *file_type(const struct stat *st)
|
||||
{
|
||||
/* See POSIX 1003.1-2001 XCU Table 4-8 lines 17093-17107
|
||||
@@ -338,8 +344,14 @@ static void print_it(const char *masterformat, const char *filename,
|
||||
#endif
|
||||
|
||||
/* Stat the file system and print what we find. */
|
||||
#if !ENABLE_FEATURE_STAT_FORMAT
|
||||
#define do_statfs(filename, format) do_statfs(filename)
|
||||
#endif
|
||||
static bool do_statfs(const char *filename, const char *format)
|
||||
{
|
||||
#if !ENABLE_FEATURE_STAT_FORMAT
|
||||
const char *format;
|
||||
#endif
|
||||
struct statfs statfsbuf;
|
||||
#if ENABLE_SELINUX
|
||||
security_context_t scontext = NULL;
|
||||
@@ -447,6 +459,9 @@ static bool do_statfs(const char *filename, const char *format)
|
||||
}
|
||||
|
||||
/* stat the file and print what we find */
|
||||
#if !ENABLE_FEATURE_STAT_FORMAT
|
||||
#define do_stat(filename, format) do_stat(filename)
|
||||
#endif
|
||||
static bool do_stat(const char *filename, const char *format)
|
||||
{
|
||||
struct stat statbuf;
|
||||
@@ -612,10 +627,10 @@ static bool do_stat(const char *filename, const char *format)
|
||||
int stat_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int stat_main(int argc, char **argv)
|
||||
{
|
||||
char *format = NULL;
|
||||
USE_FEATURE_STAT_FORMAT(char *format = NULL;)
|
||||
int i;
|
||||
int ok = 1;
|
||||
bool (*statfunc)(const char *, const char *) = do_stat;
|
||||
statfunc_ptr statfunc = do_stat;
|
||||
|
||||
getopt32(argv, "ftL"
|
||||
USE_SELINUX("Z")
|
||||
@@ -633,7 +648,7 @@ int stat_main(int argc, char **argv)
|
||||
}
|
||||
#endif /* ENABLE_SELINUX */
|
||||
for (i = optind; i < argc; ++i)
|
||||
ok &= statfunc(argv[i], format);
|
||||
ok &= statfunc(argv[i] USE_FEATURE_STAT_FORMAT(, format));
|
||||
|
||||
return (ok ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
}
|
||||
+361
-152
@@ -133,18 +133,27 @@ enum {
|
||||
#define REV 4 /* Can be turned off by prepending '-' */
|
||||
#define OMIT 8 /* Don't display value */
|
||||
|
||||
/* Each mode */
|
||||
|
||||
/* Each mode.
|
||||
* This structure should be kept as small as humanly possible.
|
||||
*/
|
||||
struct mode_info {
|
||||
const char name[9]; /* Name given on command line */
|
||||
const unsigned char type; /* Which structure element to change */
|
||||
const unsigned char flags; /* Setting and display options */
|
||||
/* were using short here, but ppc32 was unhappy: */
|
||||
const uint8_t type; /* Which structure element to change */
|
||||
const uint8_t flags; /* Setting and display options */
|
||||
/* only these values are ever used, so... */
|
||||
#if (CSIZE | NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY) < 0x100
|
||||
const uint8_t mask;
|
||||
#elif (CSIZE | NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY) < 0x10000
|
||||
const uint16_t mask;
|
||||
#else
|
||||
const tcflag_t mask; /* Other bits to turn off for this mode */
|
||||
#endif
|
||||
/* was using short here, but ppc32 was unhappy */
|
||||
const tcflag_t bits; /* Bits to set for this mode */
|
||||
};
|
||||
|
||||
enum {
|
||||
/* Must match mode_info[] order! */
|
||||
/* Must match mode_name[] and mode_info[] order! */
|
||||
IDX_evenp = 0,
|
||||
IDX_parity,
|
||||
IDX_oddp,
|
||||
@@ -170,151 +179,302 @@ enum {
|
||||
#endif
|
||||
};
|
||||
|
||||
#define MI_ENTRY(N,T,F,B,M) { N, T, F, M, B }
|
||||
#define MI_ENTRY(N,T,F,B,M) N "\0"
|
||||
|
||||
static const struct mode_info mode_info[] = {
|
||||
MI_ENTRY("evenp", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("parity", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("oddp", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("nl", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("ek", combination, OMIT, 0, 0 ),
|
||||
MI_ENTRY("sane", combination, OMIT, 0, 0 ),
|
||||
MI_ENTRY("cooked", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("raw", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("pass8", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("litout", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("cbreak", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("crt", combination, OMIT, 0, 0 ),
|
||||
MI_ENTRY("dec", combination, OMIT, 0, 0 ),
|
||||
/* Mode names given on command line */
|
||||
static const char mode_name[] =
|
||||
MI_ENTRY("evenp", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("parity", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("oddp", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("nl", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("ek", combination, OMIT, 0, 0 )
|
||||
MI_ENTRY("sane", combination, OMIT, 0, 0 )
|
||||
MI_ENTRY("cooked", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("raw", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("pass8", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("litout", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("cbreak", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("crt", combination, OMIT, 0, 0 )
|
||||
MI_ENTRY("dec", combination, OMIT, 0, 0 )
|
||||
#ifdef IXANY
|
||||
MI_ENTRY("decctlq", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("decctlq", combination, REV | OMIT, 0, 0 )
|
||||
#endif
|
||||
#if defined(TABDLY) || defined(OXTABS)
|
||||
MI_ENTRY("tabs", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("tabs", combination, REV | OMIT, 0, 0 )
|
||||
#endif
|
||||
#if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
|
||||
MI_ENTRY("lcase", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("LCASE", combination, REV | OMIT, 0, 0 ),
|
||||
MI_ENTRY("lcase", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("LCASE", combination, REV | OMIT, 0, 0 )
|
||||
#endif
|
||||
MI_ENTRY("parenb", control, REV, PARENB, 0 ),
|
||||
MI_ENTRY("parodd", control, REV, PARODD, 0 ),
|
||||
MI_ENTRY("cs5", control, 0, CS5, CSIZE),
|
||||
MI_ENTRY("cs6", control, 0, CS6, CSIZE),
|
||||
MI_ENTRY("cs7", control, 0, CS7, CSIZE),
|
||||
MI_ENTRY("cs8", control, 0, CS8, CSIZE),
|
||||
MI_ENTRY("hupcl", control, REV, HUPCL, 0 ),
|
||||
MI_ENTRY("hup", control, REV | OMIT, HUPCL, 0 ),
|
||||
MI_ENTRY("cstopb", control, REV, CSTOPB, 0 ),
|
||||
MI_ENTRY("cread", control, SANE_SET | REV, CREAD, 0 ),
|
||||
MI_ENTRY("clocal", control, REV, CLOCAL, 0 ),
|
||||
MI_ENTRY("parenb", control, REV, PARENB, 0 )
|
||||
MI_ENTRY("parodd", control, REV, PARODD, 0 )
|
||||
MI_ENTRY("cs5", control, 0, CS5, CSIZE)
|
||||
MI_ENTRY("cs6", control, 0, CS6, CSIZE)
|
||||
MI_ENTRY("cs7", control, 0, CS7, CSIZE)
|
||||
MI_ENTRY("cs8", control, 0, CS8, CSIZE)
|
||||
MI_ENTRY("hupcl", control, REV, HUPCL, 0 )
|
||||
MI_ENTRY("hup", control, REV | OMIT, HUPCL, 0 )
|
||||
MI_ENTRY("cstopb", control, REV, CSTOPB, 0 )
|
||||
MI_ENTRY("cread", control, SANE_SET | REV, CREAD, 0 )
|
||||
MI_ENTRY("clocal", control, REV, CLOCAL, 0 )
|
||||
#ifdef CRTSCTS
|
||||
MI_ENTRY("crtscts", control, REV, CRTSCTS, 0 ),
|
||||
MI_ENTRY("crtscts", control, REV, CRTSCTS, 0 )
|
||||
#endif
|
||||
MI_ENTRY("ignbrk", input, SANE_UNSET | REV, IGNBRK, 0 ),
|
||||
MI_ENTRY("brkint", input, SANE_SET | REV, BRKINT, 0 ),
|
||||
MI_ENTRY("ignpar", input, REV, IGNPAR, 0 ),
|
||||
MI_ENTRY("parmrk", input, REV, PARMRK, 0 ),
|
||||
MI_ENTRY("inpck", input, REV, INPCK, 0 ),
|
||||
MI_ENTRY("istrip", input, REV, ISTRIP, 0 ),
|
||||
MI_ENTRY("inlcr", input, SANE_UNSET | REV, INLCR, 0 ),
|
||||
MI_ENTRY("igncr", input, SANE_UNSET | REV, IGNCR, 0 ),
|
||||
MI_ENTRY("icrnl", input, SANE_SET | REV, ICRNL, 0 ),
|
||||
MI_ENTRY("ixon", input, REV, IXON, 0 ),
|
||||
MI_ENTRY("ixoff", input, SANE_UNSET | REV, IXOFF, 0 ),
|
||||
MI_ENTRY("tandem", input, REV | OMIT, IXOFF, 0 ),
|
||||
MI_ENTRY("ignbrk", input, SANE_UNSET | REV, IGNBRK, 0 )
|
||||
MI_ENTRY("brkint", input, SANE_SET | REV, BRKINT, 0 )
|
||||
MI_ENTRY("ignpar", input, REV, IGNPAR, 0 )
|
||||
MI_ENTRY("parmrk", input, REV, PARMRK, 0 )
|
||||
MI_ENTRY("inpck", input, REV, INPCK, 0 )
|
||||
MI_ENTRY("istrip", input, REV, ISTRIP, 0 )
|
||||
MI_ENTRY("inlcr", input, SANE_UNSET | REV, INLCR, 0 )
|
||||
MI_ENTRY("igncr", input, SANE_UNSET | REV, IGNCR, 0 )
|
||||
MI_ENTRY("icrnl", input, SANE_SET | REV, ICRNL, 0 )
|
||||
MI_ENTRY("ixon", input, REV, IXON, 0 )
|
||||
MI_ENTRY("ixoff", input, SANE_UNSET | REV, IXOFF, 0 )
|
||||
MI_ENTRY("tandem", input, REV | OMIT, IXOFF, 0 )
|
||||
#ifdef IUCLC
|
||||
MI_ENTRY("iuclc", input, SANE_UNSET | REV, IUCLC, 0 ),
|
||||
MI_ENTRY("iuclc", input, SANE_UNSET | REV, IUCLC, 0 )
|
||||
#endif
|
||||
#ifdef IXANY
|
||||
MI_ENTRY("ixany", input, SANE_UNSET | REV, IXANY, 0 ),
|
||||
MI_ENTRY("ixany", input, SANE_UNSET | REV, IXANY, 0 )
|
||||
#endif
|
||||
#ifdef IMAXBEL
|
||||
MI_ENTRY("imaxbel", input, SANE_SET | REV, IMAXBEL, 0 ),
|
||||
MI_ENTRY("imaxbel", input, SANE_SET | REV, IMAXBEL, 0 )
|
||||
#endif
|
||||
MI_ENTRY("opost", output, SANE_SET | REV, OPOST, 0 ),
|
||||
MI_ENTRY("opost", output, SANE_SET | REV, OPOST, 0 )
|
||||
#ifdef OLCUC
|
||||
MI_ENTRY("olcuc", output, SANE_UNSET | REV, OLCUC, 0 ),
|
||||
MI_ENTRY("olcuc", output, SANE_UNSET | REV, OLCUC, 0 )
|
||||
#endif
|
||||
#ifdef OCRNL
|
||||
MI_ENTRY("ocrnl", output, SANE_UNSET | REV, OCRNL, 0 ),
|
||||
MI_ENTRY("ocrnl", output, SANE_UNSET | REV, OCRNL, 0 )
|
||||
#endif
|
||||
#ifdef ONLCR
|
||||
MI_ENTRY("onlcr", output, SANE_SET | REV, ONLCR, 0 ),
|
||||
MI_ENTRY("onlcr", output, SANE_SET | REV, ONLCR, 0 )
|
||||
#endif
|
||||
#ifdef ONOCR
|
||||
MI_ENTRY("onocr", output, SANE_UNSET | REV, ONOCR, 0 ),
|
||||
MI_ENTRY("onocr", output, SANE_UNSET | REV, ONOCR, 0 )
|
||||
#endif
|
||||
#ifdef ONLRET
|
||||
MI_ENTRY("onlret", output, SANE_UNSET | REV, ONLRET, 0 ),
|
||||
MI_ENTRY("onlret", output, SANE_UNSET | REV, ONLRET, 0 )
|
||||
#endif
|
||||
#ifdef OFILL
|
||||
MI_ENTRY("ofill", output, SANE_UNSET | REV, OFILL, 0 ),
|
||||
MI_ENTRY("ofill", output, SANE_UNSET | REV, OFILL, 0 )
|
||||
#endif
|
||||
#ifdef OFDEL
|
||||
MI_ENTRY("ofdel", output, SANE_UNSET | REV, OFDEL, 0 ),
|
||||
MI_ENTRY("ofdel", output, SANE_UNSET | REV, OFDEL, 0 )
|
||||
#endif
|
||||
#ifdef NLDLY
|
||||
MI_ENTRY("nl1", output, SANE_UNSET, NL1, NLDLY),
|
||||
MI_ENTRY("nl0", output, SANE_SET, NL0, NLDLY),
|
||||
MI_ENTRY("nl1", output, SANE_UNSET, NL1, NLDLY)
|
||||
MI_ENTRY("nl0", output, SANE_SET, NL0, NLDLY)
|
||||
#endif
|
||||
#ifdef CRDLY
|
||||
MI_ENTRY("cr3", output, SANE_UNSET, CR3, CRDLY),
|
||||
MI_ENTRY("cr2", output, SANE_UNSET, CR2, CRDLY),
|
||||
MI_ENTRY("cr1", output, SANE_UNSET, CR1, CRDLY),
|
||||
MI_ENTRY("cr0", output, SANE_SET, CR0, CRDLY),
|
||||
MI_ENTRY("cr3", output, SANE_UNSET, CR3, CRDLY)
|
||||
MI_ENTRY("cr2", output, SANE_UNSET, CR2, CRDLY)
|
||||
MI_ENTRY("cr1", output, SANE_UNSET, CR1, CRDLY)
|
||||
MI_ENTRY("cr0", output, SANE_SET, CR0, CRDLY)
|
||||
#endif
|
||||
|
||||
#ifdef TABDLY
|
||||
MI_ENTRY("tab3", output, SANE_UNSET, TAB3, TABDLY),
|
||||
MI_ENTRY("tab2", output, SANE_UNSET, TAB2, TABDLY),
|
||||
MI_ENTRY("tab1", output, SANE_UNSET, TAB1, TABDLY),
|
||||
MI_ENTRY("tab0", output, SANE_SET, TAB0, TABDLY),
|
||||
MI_ENTRY("tab3", output, SANE_UNSET, TAB3, TABDLY)
|
||||
MI_ENTRY("tab2", output, SANE_UNSET, TAB2, TABDLY)
|
||||
MI_ENTRY("tab1", output, SANE_UNSET, TAB1, TABDLY)
|
||||
MI_ENTRY("tab0", output, SANE_SET, TAB0, TABDLY)
|
||||
#else
|
||||
# ifdef OXTABS
|
||||
MI_ENTRY("tab3", output, SANE_UNSET, OXTABS, 0 ),
|
||||
MI_ENTRY("tab3", output, SANE_UNSET, OXTABS, 0 )
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef BSDLY
|
||||
MI_ENTRY("bs1", output, SANE_UNSET, BS1, BSDLY),
|
||||
MI_ENTRY("bs0", output, SANE_SET, BS0, BSDLY),
|
||||
MI_ENTRY("bs1", output, SANE_UNSET, BS1, BSDLY)
|
||||
MI_ENTRY("bs0", output, SANE_SET, BS0, BSDLY)
|
||||
#endif
|
||||
#ifdef VTDLY
|
||||
MI_ENTRY("vt1", output, SANE_UNSET, VT1, VTDLY),
|
||||
MI_ENTRY("vt0", output, SANE_SET, VT0, VTDLY),
|
||||
MI_ENTRY("vt1", output, SANE_UNSET, VT1, VTDLY)
|
||||
MI_ENTRY("vt0", output, SANE_SET, VT0, VTDLY)
|
||||
#endif
|
||||
#ifdef FFDLY
|
||||
MI_ENTRY("ff1", output, SANE_UNSET, FF1, FFDLY),
|
||||
MI_ENTRY("ff0", output, SANE_SET, FF0, FFDLY),
|
||||
MI_ENTRY("ff1", output, SANE_UNSET, FF1, FFDLY)
|
||||
MI_ENTRY("ff0", output, SANE_SET, FF0, FFDLY)
|
||||
#endif
|
||||
MI_ENTRY("isig", local, SANE_SET | REV, ISIG, 0 ),
|
||||
MI_ENTRY("icanon", local, SANE_SET | REV, ICANON, 0 ),
|
||||
MI_ENTRY("isig", local, SANE_SET | REV, ISIG, 0 )
|
||||
MI_ENTRY("icanon", local, SANE_SET | REV, ICANON, 0 )
|
||||
#ifdef IEXTEN
|
||||
MI_ENTRY("iexten", local, SANE_SET | REV, IEXTEN, 0 ),
|
||||
MI_ENTRY("iexten", local, SANE_SET | REV, IEXTEN, 0 )
|
||||
#endif
|
||||
MI_ENTRY("echo", local, SANE_SET | REV, ECHO, 0 ),
|
||||
MI_ENTRY("echoe", local, SANE_SET | REV, ECHOE, 0 ),
|
||||
MI_ENTRY("crterase", local, REV | OMIT, ECHOE, 0 ),
|
||||
MI_ENTRY("echok", local, SANE_SET | REV, ECHOK, 0 ),
|
||||
MI_ENTRY("echonl", local, SANE_UNSET | REV, ECHONL, 0 ),
|
||||
MI_ENTRY("noflsh", local, SANE_UNSET | REV, NOFLSH, 0 ),
|
||||
MI_ENTRY("echo", local, SANE_SET | REV, ECHO, 0 )
|
||||
MI_ENTRY("echoe", local, SANE_SET | REV, ECHOE, 0 )
|
||||
MI_ENTRY("crterase", local, REV | OMIT, ECHOE, 0 )
|
||||
MI_ENTRY("echok", local, SANE_SET | REV, ECHOK, 0 )
|
||||
MI_ENTRY("echonl", local, SANE_UNSET | REV, ECHONL, 0 )
|
||||
MI_ENTRY("noflsh", local, SANE_UNSET | REV, NOFLSH, 0 )
|
||||
#ifdef XCASE
|
||||
MI_ENTRY("xcase", local, SANE_UNSET | REV, XCASE, 0 ),
|
||||
MI_ENTRY("xcase", local, SANE_UNSET | REV, XCASE, 0 )
|
||||
#endif
|
||||
#ifdef TOSTOP
|
||||
MI_ENTRY("tostop", local, SANE_UNSET | REV, TOSTOP, 0 ),
|
||||
MI_ENTRY("tostop", local, SANE_UNSET | REV, TOSTOP, 0 )
|
||||
#endif
|
||||
#ifdef ECHOPRT
|
||||
MI_ENTRY("echoprt", local, SANE_UNSET | REV, ECHOPRT, 0 ),
|
||||
MI_ENTRY("prterase", local, REV | OMIT, ECHOPRT, 0 ),
|
||||
MI_ENTRY("echoprt", local, SANE_UNSET | REV, ECHOPRT, 0 )
|
||||
MI_ENTRY("prterase", local, REV | OMIT, ECHOPRT, 0 )
|
||||
#endif
|
||||
#ifdef ECHOCTL
|
||||
MI_ENTRY("echoctl", local, SANE_SET | REV, ECHOCTL, 0 ),
|
||||
MI_ENTRY("ctlecho", local, REV | OMIT, ECHOCTL, 0 ),
|
||||
MI_ENTRY("echoctl", local, SANE_SET | REV, ECHOCTL, 0 )
|
||||
MI_ENTRY("ctlecho", local, REV | OMIT, ECHOCTL, 0 )
|
||||
#endif
|
||||
#ifdef ECHOKE
|
||||
MI_ENTRY("echoke", local, SANE_SET | REV, ECHOKE, 0 ),
|
||||
MI_ENTRY("crtkill", local, REV | OMIT, ECHOKE, 0 ),
|
||||
MI_ENTRY("echoke", local, SANE_SET | REV, ECHOKE, 0 )
|
||||
MI_ENTRY("crtkill", local, REV | OMIT, ECHOKE, 0 )
|
||||
#endif
|
||||
;
|
||||
|
||||
#undef MI_ENTRY
|
||||
#define MI_ENTRY(N,T,F,B,M) { T, F, M, B },
|
||||
|
||||
static const struct mode_info mode_info[] = {
|
||||
/* This should be verbatim cut-n-paste copy of the above MI_ENTRYs */
|
||||
MI_ENTRY("evenp", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("parity", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("oddp", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("nl", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("ek", combination, OMIT, 0, 0 )
|
||||
MI_ENTRY("sane", combination, OMIT, 0, 0 )
|
||||
MI_ENTRY("cooked", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("raw", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("pass8", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("litout", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("cbreak", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("crt", combination, OMIT, 0, 0 )
|
||||
MI_ENTRY("dec", combination, OMIT, 0, 0 )
|
||||
#ifdef IXANY
|
||||
MI_ENTRY("decctlq", combination, REV | OMIT, 0, 0 )
|
||||
#endif
|
||||
#if defined(TABDLY) || defined(OXTABS)
|
||||
MI_ENTRY("tabs", combination, REV | OMIT, 0, 0 )
|
||||
#endif
|
||||
#if defined(XCASE) && defined(IUCLC) && defined(OLCUC)
|
||||
MI_ENTRY("lcase", combination, REV | OMIT, 0, 0 )
|
||||
MI_ENTRY("LCASE", combination, REV | OMIT, 0, 0 )
|
||||
#endif
|
||||
MI_ENTRY("parenb", control, REV, PARENB, 0 )
|
||||
MI_ENTRY("parodd", control, REV, PARODD, 0 )
|
||||
MI_ENTRY("cs5", control, 0, CS5, CSIZE)
|
||||
MI_ENTRY("cs6", control, 0, CS6, CSIZE)
|
||||
MI_ENTRY("cs7", control, 0, CS7, CSIZE)
|
||||
MI_ENTRY("cs8", control, 0, CS8, CSIZE)
|
||||
MI_ENTRY("hupcl", control, REV, HUPCL, 0 )
|
||||
MI_ENTRY("hup", control, REV | OMIT, HUPCL, 0 )
|
||||
MI_ENTRY("cstopb", control, REV, CSTOPB, 0 )
|
||||
MI_ENTRY("cread", control, SANE_SET | REV, CREAD, 0 )
|
||||
MI_ENTRY("clocal", control, REV, CLOCAL, 0 )
|
||||
#ifdef CRTSCTS
|
||||
MI_ENTRY("crtscts", control, REV, CRTSCTS, 0 )
|
||||
#endif
|
||||
MI_ENTRY("ignbrk", input, SANE_UNSET | REV, IGNBRK, 0 )
|
||||
MI_ENTRY("brkint", input, SANE_SET | REV, BRKINT, 0 )
|
||||
MI_ENTRY("ignpar", input, REV, IGNPAR, 0 )
|
||||
MI_ENTRY("parmrk", input, REV, PARMRK, 0 )
|
||||
MI_ENTRY("inpck", input, REV, INPCK, 0 )
|
||||
MI_ENTRY("istrip", input, REV, ISTRIP, 0 )
|
||||
MI_ENTRY("inlcr", input, SANE_UNSET | REV, INLCR, 0 )
|
||||
MI_ENTRY("igncr", input, SANE_UNSET | REV, IGNCR, 0 )
|
||||
MI_ENTRY("icrnl", input, SANE_SET | REV, ICRNL, 0 )
|
||||
MI_ENTRY("ixon", input, REV, IXON, 0 )
|
||||
MI_ENTRY("ixoff", input, SANE_UNSET | REV, IXOFF, 0 )
|
||||
MI_ENTRY("tandem", input, REV | OMIT, IXOFF, 0 )
|
||||
#ifdef IUCLC
|
||||
MI_ENTRY("iuclc", input, SANE_UNSET | REV, IUCLC, 0 )
|
||||
#endif
|
||||
#ifdef IXANY
|
||||
MI_ENTRY("ixany", input, SANE_UNSET | REV, IXANY, 0 )
|
||||
#endif
|
||||
#ifdef IMAXBEL
|
||||
MI_ENTRY("imaxbel", input, SANE_SET | REV, IMAXBEL, 0 )
|
||||
#endif
|
||||
MI_ENTRY("opost", output, SANE_SET | REV, OPOST, 0 )
|
||||
#ifdef OLCUC
|
||||
MI_ENTRY("olcuc", output, SANE_UNSET | REV, OLCUC, 0 )
|
||||
#endif
|
||||
#ifdef OCRNL
|
||||
MI_ENTRY("ocrnl", output, SANE_UNSET | REV, OCRNL, 0 )
|
||||
#endif
|
||||
#ifdef ONLCR
|
||||
MI_ENTRY("onlcr", output, SANE_SET | REV, ONLCR, 0 )
|
||||
#endif
|
||||
#ifdef ONOCR
|
||||
MI_ENTRY("onocr", output, SANE_UNSET | REV, ONOCR, 0 )
|
||||
#endif
|
||||
#ifdef ONLRET
|
||||
MI_ENTRY("onlret", output, SANE_UNSET | REV, ONLRET, 0 )
|
||||
#endif
|
||||
#ifdef OFILL
|
||||
MI_ENTRY("ofill", output, SANE_UNSET | REV, OFILL, 0 )
|
||||
#endif
|
||||
#ifdef OFDEL
|
||||
MI_ENTRY("ofdel", output, SANE_UNSET | REV, OFDEL, 0 )
|
||||
#endif
|
||||
#ifdef NLDLY
|
||||
MI_ENTRY("nl1", output, SANE_UNSET, NL1, NLDLY)
|
||||
MI_ENTRY("nl0", output, SANE_SET, NL0, NLDLY)
|
||||
#endif
|
||||
#ifdef CRDLY
|
||||
MI_ENTRY("cr3", output, SANE_UNSET, CR3, CRDLY)
|
||||
MI_ENTRY("cr2", output, SANE_UNSET, CR2, CRDLY)
|
||||
MI_ENTRY("cr1", output, SANE_UNSET, CR1, CRDLY)
|
||||
MI_ENTRY("cr0", output, SANE_SET, CR0, CRDLY)
|
||||
#endif
|
||||
|
||||
#ifdef TABDLY
|
||||
MI_ENTRY("tab3", output, SANE_UNSET, TAB3, TABDLY)
|
||||
MI_ENTRY("tab2", output, SANE_UNSET, TAB2, TABDLY)
|
||||
MI_ENTRY("tab1", output, SANE_UNSET, TAB1, TABDLY)
|
||||
MI_ENTRY("tab0", output, SANE_SET, TAB0, TABDLY)
|
||||
#else
|
||||
# ifdef OXTABS
|
||||
MI_ENTRY("tab3", output, SANE_UNSET, OXTABS, 0 )
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef BSDLY
|
||||
MI_ENTRY("bs1", output, SANE_UNSET, BS1, BSDLY)
|
||||
MI_ENTRY("bs0", output, SANE_SET, BS0, BSDLY)
|
||||
#endif
|
||||
#ifdef VTDLY
|
||||
MI_ENTRY("vt1", output, SANE_UNSET, VT1, VTDLY)
|
||||
MI_ENTRY("vt0", output, SANE_SET, VT0, VTDLY)
|
||||
#endif
|
||||
#ifdef FFDLY
|
||||
MI_ENTRY("ff1", output, SANE_UNSET, FF1, FFDLY)
|
||||
MI_ENTRY("ff0", output, SANE_SET, FF0, FFDLY)
|
||||
#endif
|
||||
MI_ENTRY("isig", local, SANE_SET | REV, ISIG, 0 )
|
||||
MI_ENTRY("icanon", local, SANE_SET | REV, ICANON, 0 )
|
||||
#ifdef IEXTEN
|
||||
MI_ENTRY("iexten", local, SANE_SET | REV, IEXTEN, 0 )
|
||||
#endif
|
||||
MI_ENTRY("echo", local, SANE_SET | REV, ECHO, 0 )
|
||||
MI_ENTRY("echoe", local, SANE_SET | REV, ECHOE, 0 )
|
||||
MI_ENTRY("crterase", local, REV | OMIT, ECHOE, 0 )
|
||||
MI_ENTRY("echok", local, SANE_SET | REV, ECHOK, 0 )
|
||||
MI_ENTRY("echonl", local, SANE_UNSET | REV, ECHONL, 0 )
|
||||
MI_ENTRY("noflsh", local, SANE_UNSET | REV, NOFLSH, 0 )
|
||||
#ifdef XCASE
|
||||
MI_ENTRY("xcase", local, SANE_UNSET | REV, XCASE, 0 )
|
||||
#endif
|
||||
#ifdef TOSTOP
|
||||
MI_ENTRY("tostop", local, SANE_UNSET | REV, TOSTOP, 0 )
|
||||
#endif
|
||||
#ifdef ECHOPRT
|
||||
MI_ENTRY("echoprt", local, SANE_UNSET | REV, ECHOPRT, 0 )
|
||||
MI_ENTRY("prterase", local, REV | OMIT, ECHOPRT, 0 )
|
||||
#endif
|
||||
#ifdef ECHOCTL
|
||||
MI_ENTRY("echoctl", local, SANE_SET | REV, ECHOCTL, 0 )
|
||||
MI_ENTRY("ctlecho", local, REV | OMIT, ECHOCTL, 0 )
|
||||
#endif
|
||||
#ifdef ECHOKE
|
||||
MI_ENTRY("echoke", local, SANE_SET | REV, ECHOKE, 0 )
|
||||
MI_ENTRY("crtkill", local, REV | OMIT, ECHOKE, 0 )
|
||||
#endif
|
||||
};
|
||||
|
||||
@@ -322,15 +482,15 @@ enum {
|
||||
NUM_mode_info = ARRAY_SIZE(mode_info)
|
||||
};
|
||||
|
||||
|
||||
/* Control characters */
|
||||
struct control_info {
|
||||
const char name[7]; /* Name given on command line */
|
||||
const unsigned char saneval; /* Value to set for 'stty sane' */
|
||||
const unsigned char offset; /* Offset in c_cc */
|
||||
const uint8_t saneval; /* Value to set for 'stty sane' */
|
||||
const uint8_t offset; /* Offset in c_cc */
|
||||
};
|
||||
|
||||
enum {
|
||||
/* Must match control_info[] order! */
|
||||
/* Must match control_name[] and control_info[] order! */
|
||||
CIDX_intr = 0,
|
||||
CIDX_quit,
|
||||
CIDX_erase,
|
||||
@@ -368,60 +528,111 @@ enum {
|
||||
CIDX_time,
|
||||
};
|
||||
|
||||
static const struct control_info control_info[] = {
|
||||
{"intr", CINTR, VINTR},
|
||||
{"quit", CQUIT, VQUIT},
|
||||
{"erase", CERASE, VERASE},
|
||||
{"kill", CKILL, VKILL},
|
||||
{"eof", CEOF, VEOF},
|
||||
{"eol", CEOL, VEOL},
|
||||
#define CI_ENTRY(n,s,o) n "\0"
|
||||
|
||||
/* Name given on command line */
|
||||
static const char control_name[] =
|
||||
CI_ENTRY("intr", CINTR, VINTR )
|
||||
CI_ENTRY("quit", CQUIT, VQUIT )
|
||||
CI_ENTRY("erase", CERASE, VERASE )
|
||||
CI_ENTRY("kill", CKILL, VKILL )
|
||||
CI_ENTRY("eof", CEOF, VEOF )
|
||||
CI_ENTRY("eol", CEOL, VEOL )
|
||||
#ifdef VEOL2
|
||||
{"eol2", CEOL2, VEOL2},
|
||||
CI_ENTRY("eol2", CEOL2, VEOL2 )
|
||||
#endif
|
||||
#ifdef VSWTCH
|
||||
{"swtch", CSWTCH, VSWTCH},
|
||||
CI_ENTRY("swtch", CSWTCH, VSWTCH )
|
||||
#endif
|
||||
{"start", CSTART, VSTART},
|
||||
{"stop", CSTOP, VSTOP},
|
||||
{"susp", CSUSP, VSUSP},
|
||||
CI_ENTRY("start", CSTART, VSTART )
|
||||
CI_ENTRY("stop", CSTOP, VSTOP )
|
||||
CI_ENTRY("susp", CSUSP, VSUSP )
|
||||
#ifdef VDSUSP
|
||||
{"dsusp", CDSUSP, VDSUSP},
|
||||
CI_ENTRY("dsusp", CDSUSP, VDSUSP )
|
||||
#endif
|
||||
#ifdef VREPRINT
|
||||
{"rprnt", CRPRNT, VREPRINT},
|
||||
CI_ENTRY("rprnt", CRPRNT, VREPRINT)
|
||||
#endif
|
||||
#ifdef VWERASE
|
||||
{"werase", CWERASE, VWERASE},
|
||||
CI_ENTRY("werase", CWERASE, VWERASE )
|
||||
#endif
|
||||
#ifdef VLNEXT
|
||||
{"lnext", CLNEXT, VLNEXT},
|
||||
CI_ENTRY("lnext", CLNEXT, VLNEXT )
|
||||
#endif
|
||||
#ifdef VFLUSHO
|
||||
{"flush", CFLUSHO, VFLUSHO},
|
||||
CI_ENTRY("flush", CFLUSHO, VFLUSHO )
|
||||
#endif
|
||||
#ifdef VSTATUS
|
||||
{"status", CSTATUS, VSTATUS},
|
||||
CI_ENTRY("status", CSTATUS, VSTATUS )
|
||||
#endif
|
||||
/* These must be last because of the display routines */
|
||||
{"min", 1, VMIN},
|
||||
{"time", 0, VTIME},
|
||||
CI_ENTRY("min", 1, VMIN )
|
||||
CI_ENTRY("time", 0, VTIME )
|
||||
;
|
||||
|
||||
#undef CI_ENTRY
|
||||
#define CI_ENTRY(n,s,o) { s, o },
|
||||
|
||||
static const struct control_info control_info[] = {
|
||||
/* This should be verbatim cut-n-paste copy of the above CI_ENTRYs */
|
||||
CI_ENTRY("intr", CINTR, VINTR )
|
||||
CI_ENTRY("quit", CQUIT, VQUIT )
|
||||
CI_ENTRY("erase", CERASE, VERASE )
|
||||
CI_ENTRY("kill", CKILL, VKILL )
|
||||
CI_ENTRY("eof", CEOF, VEOF )
|
||||
CI_ENTRY("eol", CEOL, VEOL )
|
||||
#ifdef VEOL2
|
||||
CI_ENTRY("eol2", CEOL2, VEOL2 )
|
||||
#endif
|
||||
#ifdef VSWTCH
|
||||
CI_ENTRY("swtch", CSWTCH, VSWTCH )
|
||||
#endif
|
||||
CI_ENTRY("start", CSTART, VSTART )
|
||||
CI_ENTRY("stop", CSTOP, VSTOP )
|
||||
CI_ENTRY("susp", CSUSP, VSUSP )
|
||||
#ifdef VDSUSP
|
||||
CI_ENTRY("dsusp", CDSUSP, VDSUSP )
|
||||
#endif
|
||||
#ifdef VREPRINT
|
||||
CI_ENTRY("rprnt", CRPRNT, VREPRINT)
|
||||
#endif
|
||||
#ifdef VWERASE
|
||||
CI_ENTRY("werase", CWERASE, VWERASE )
|
||||
#endif
|
||||
#ifdef VLNEXT
|
||||
CI_ENTRY("lnext", CLNEXT, VLNEXT )
|
||||
#endif
|
||||
#ifdef VFLUSHO
|
||||
CI_ENTRY("flush", CFLUSHO, VFLUSHO )
|
||||
#endif
|
||||
#ifdef VSTATUS
|
||||
CI_ENTRY("status", CSTATUS, VSTATUS )
|
||||
#endif
|
||||
/* These must be last because of the display routines */
|
||||
CI_ENTRY("min", 1, VMIN )
|
||||
CI_ENTRY("time", 0, VTIME )
|
||||
};
|
||||
|
||||
enum {
|
||||
NUM_control_info = ARRAY_SIZE(control_info)
|
||||
};
|
||||
|
||||
/* The width of the screen, for output wrapping */
|
||||
unsigned max_col = 80; /* default */
|
||||
|
||||
struct globals {
|
||||
const char *device_name; // = bb_msg_standard_input;
|
||||
/* The width of the screen, for output wrapping */
|
||||
unsigned max_col; // = 80;
|
||||
/* Current position, to know when to wrap */
|
||||
unsigned current_col;
|
||||
char buf[10];
|
||||
};
|
||||
#define G (*(struct globals*)&bb_common_bufsiz1)
|
||||
#define INIT_G() \
|
||||
do { \
|
||||
G.device_name = bb_msg_standard_input; \
|
||||
G.max_col = 80; \
|
||||
} while (0)
|
||||
|
||||
static const char *device_name = bb_msg_standard_input;
|
||||
|
||||
/* Return a string that is the printable representation of character CH */
|
||||
/* Adapted from 'cat' by Torbjorn Granlund */
|
||||
@@ -454,7 +665,7 @@ static const char *visible(unsigned ch)
|
||||
|
||||
static tcflag_t *mode_type_flag(unsigned type, const struct termios *mode)
|
||||
{
|
||||
static const unsigned char tcflag_offsets[] ALIGN1 = {
|
||||
static const uint8_t tcflag_offsets[] ALIGN1 = {
|
||||
offsetof(struct termios, c_cflag), /* control */
|
||||
offsetof(struct termios, c_iflag), /* input */
|
||||
offsetof(struct termios, c_oflag), /* output */
|
||||
@@ -484,12 +695,12 @@ static void set_speed_or_die(enum speed_setting type, const char *const arg,
|
||||
|
||||
static ATTRIBUTE_NORETURN void perror_on_device_and_die(const char *fmt)
|
||||
{
|
||||
bb_perror_msg_and_die(fmt, device_name);
|
||||
bb_perror_msg_and_die(fmt, G.device_name);
|
||||
}
|
||||
|
||||
static void perror_on_device(const char *fmt)
|
||||
{
|
||||
bb_perror_msg(fmt, device_name);
|
||||
bb_perror_msg(fmt, G.device_name);
|
||||
}
|
||||
|
||||
/* Print format string MESSAGE and optional args.
|
||||
@@ -511,7 +722,7 @@ static void wrapf(const char *message, ...)
|
||||
if (G.current_col > 0) {
|
||||
G.current_col++;
|
||||
if (buf[0] != '\n') {
|
||||
if (G.current_col + buflen >= max_col) {
|
||||
if (G.current_col + buflen >= G.max_col) {
|
||||
bb_putchar('\n');
|
||||
G.current_col = 0;
|
||||
} else
|
||||
@@ -526,7 +737,7 @@ static void wrapf(const char *message, ...)
|
||||
|
||||
static void set_window_size(const int rows, const int cols)
|
||||
{
|
||||
struct winsize win = { 0, 0, 0, 0};
|
||||
struct winsize win = { 0, 0, 0, 0 };
|
||||
|
||||
if (ioctl(STDIN_FILENO, TIOCGWINSZ, &win)) {
|
||||
if (errno != EINVAL) {
|
||||
@@ -569,20 +780,14 @@ static const struct suffix_mult stty_suffixes[] = {
|
||||
|
||||
static const struct mode_info *find_mode(const char *name)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < NUM_mode_info; ++i)
|
||||
if (!strcmp(name, mode_info[i].name))
|
||||
return &mode_info[i];
|
||||
return 0;
|
||||
int i = index_in_strings(mode_name, name);
|
||||
return i >= 0 ? &mode_info[i] : NULL;
|
||||
}
|
||||
|
||||
static const struct control_info *find_control(const char *name)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < NUM_control_info; ++i)
|
||||
if (!strcmp(name, control_info[i].name))
|
||||
return &control_info[i];
|
||||
return 0;
|
||||
int i = index_in_strings(control_name, name);
|
||||
return i >= 0 ? &control_info[i] : NULL;
|
||||
}
|
||||
|
||||
enum {
|
||||
@@ -704,7 +909,7 @@ static void do_display(const struct termios *mode, const int all)
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
wrapf("%s = %s;", control_info[i].name,
|
||||
wrapf("%s = %s;", nth_string(control_name, i),
|
||||
visible(mode->c_cc[control_info[i].offset]));
|
||||
}
|
||||
#if VEOF == VMIN
|
||||
@@ -726,12 +931,13 @@ static void do_display(const struct termios *mode, const int all)
|
||||
mask = mode_info[i].mask ? mode_info[i].mask : mode_info[i].bits;
|
||||
if ((*bitsp & mask) == mode_info[i].bits) {
|
||||
if (all || (mode_info[i].flags & SANE_UNSET))
|
||||
wrapf("%s", mode_info[i].name);
|
||||
wrapf("-%s"+1, nth_string(mode_name, i));
|
||||
} else {
|
||||
if ((all && mode_info[i].flags & REV) ||
|
||||
(!all &&
|
||||
(mode_info[i].flags & (SANE_SET | REV)) == (SANE_SET | REV)))
|
||||
wrapf("-%s", mode_info[i].name);
|
||||
if ((all && mode_info[i].flags & REV)
|
||||
|| (!all && (mode_info[i].flags & (SANE_SET | REV)) == (SANE_SET | REV))
|
||||
) {
|
||||
wrapf("-%s", nth_string(mode_name, i));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (G.current_col) wrapf("\n");
|
||||
@@ -861,8 +1067,8 @@ static void set_mode(const struct mode_info *info, int reversed,
|
||||
mode->c_oflag &= ~OPOST;
|
||||
}
|
||||
} else if (info == &mode_info[IDX_raw] || info == &mode_info[IDX_cooked]) {
|
||||
if ((info->name[0] == 'r' && reversed)
|
||||
|| (info->name[0] == 'c' && !reversed)
|
||||
if ((info == &mode_info[IDX_raw] && reversed)
|
||||
|| (info == &mode_info[IDX_cooked] && !reversed)
|
||||
) {
|
||||
/* Cooked mode */
|
||||
mode->c_iflag |= BRKINT | IGNPAR | ISTRIP | ICRNL | IXON;
|
||||
@@ -944,11 +1150,12 @@ static void set_control_char_or_die(const struct control_info *info,
|
||||
mode->c_cc[info->offset] = value;
|
||||
}
|
||||
|
||||
#define STTY_require_set_attr (1<<0)
|
||||
#define STTY_speed_was_set (1<<1)
|
||||
#define STTY_verbose_output (1<<2)
|
||||
#define STTY_recoverable_output (1<<3)
|
||||
#define STTY_noargs (1<<4)
|
||||
#define STTY_require_set_attr (1 << 0)
|
||||
#define STTY_speed_was_set (1 << 1)
|
||||
#define STTY_verbose_output (1 << 2)
|
||||
#define STTY_recoverable_output (1 << 3)
|
||||
#define STTY_noargs (1 << 4)
|
||||
|
||||
int stty_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int stty_main(int argc, char **argv)
|
||||
{
|
||||
@@ -959,6 +1166,8 @@ int stty_main(int argc, char **argv)
|
||||
int stty_state;
|
||||
int k;
|
||||
|
||||
INIT_G();
|
||||
|
||||
stty_state = STTY_noargs;
|
||||
output_func = do_display;
|
||||
|
||||
@@ -1086,8 +1295,8 @@ int stty_main(int argc, char **argv)
|
||||
/* Now it is safe to start doing things */
|
||||
if (file_name) {
|
||||
int fd, fdflags;
|
||||
device_name = file_name;
|
||||
fd = xopen(device_name, O_RDONLY | O_NONBLOCK);
|
||||
G.device_name = file_name;
|
||||
fd = xopen(G.device_name, O_RDONLY | O_NONBLOCK);
|
||||
if (fd != STDIN_FILENO) {
|
||||
dup2(fd, STDIN_FILENO);
|
||||
close(fd);
|
||||
@@ -1105,7 +1314,7 @@ int stty_main(int argc, char **argv)
|
||||
perror_on_device_and_die("%s");
|
||||
|
||||
if (stty_state & (STTY_verbose_output | STTY_recoverable_output | STTY_noargs)) {
|
||||
get_terminal_width_height(STDOUT_FILENO, &max_col, NULL);
|
||||
get_terminal_width_height(STDOUT_FILENO, &G.max_col, NULL);
|
||||
output_func(&mode, display_all);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
+13
-14
@@ -21,20 +21,17 @@ enum { SUM_BSD, PRINT_NAME, SUM_SYSV };
|
||||
The checksum varies depending on sizeof (int). */
|
||||
/* SYSV: calculate and print the checksum and the size in 512-byte blocks */
|
||||
/* Return 1 if successful. */
|
||||
static unsigned sum_file(const char *file, const unsigned type)
|
||||
static unsigned sum_file(const char *file, unsigned type)
|
||||
{
|
||||
#define buf bb_common_bufsiz1
|
||||
unsigned long long total_bytes = 0;
|
||||
int fd = 0, r;
|
||||
|
||||
int fd, r;
|
||||
/* The sum of all the input bytes, modulo (UINT_MAX + 1). */
|
||||
unsigned s = 0;
|
||||
|
||||
if (NOT_LONE_DASH(file)) {
|
||||
fd = open(file, O_RDONLY);
|
||||
if (fd == -1)
|
||||
goto ret_bad;
|
||||
}
|
||||
fd = open_or_warn_stdin(file);
|
||||
if (fd == -1)
|
||||
return 0;
|
||||
|
||||
while (1) {
|
||||
size_t bytes_read = safe_read(fd, buf, BUFSIZ);
|
||||
@@ -44,7 +41,6 @@ static unsigned sum_file(const char *file, const unsigned type)
|
||||
if (!bytes_read && !r)
|
||||
/* no error */
|
||||
break;
|
||||
ret_bad:
|
||||
bb_perror_msg(file);
|
||||
return 0;
|
||||
}
|
||||
@@ -75,26 +71,29 @@ static unsigned sum_file(const char *file, const unsigned type)
|
||||
}
|
||||
|
||||
int sum_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int sum_main(int argc, char **argv)
|
||||
int sum_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
unsigned n;
|
||||
unsigned type = SUM_BSD;
|
||||
|
||||
n = getopt32(argv, "sr");
|
||||
argv += optind;
|
||||
if (n & 1) type = SUM_SYSV;
|
||||
/* give the bsd priority over sysv func */
|
||||
if (n & 2) type = SUM_BSD;
|
||||
|
||||
if (argc == optind) {
|
||||
if (!argv[0]) {
|
||||
/* Do not print the name */
|
||||
n = sum_file("-", type);
|
||||
} else {
|
||||
/* Need to print the name if either
|
||||
- more than one file given
|
||||
- doing sysv */
|
||||
type += argc - 1 > optind || type == SUM_SYSV;
|
||||
for (n = 1; optind < argc; optind++)
|
||||
n &= sum_file(argv[optind], type);
|
||||
type += (argv[1] || type == SUM_SYSV);
|
||||
n = 1;
|
||||
do {
|
||||
n &= sum_file(*argv, type);
|
||||
} while (*++argv);
|
||||
}
|
||||
return !n;
|
||||
}
|
||||
+2
-1
@@ -14,8 +14,9 @@
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
int sync_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int sync_main(int argc, char **argv)
|
||||
int sync_main(int argc, char **argv ATTRIBUTE_UNUSED)
|
||||
{
|
||||
/* coreutils-6.9 compat */
|
||||
bb_warn_ignoring_args(argc - 1);
|
||||
|
||||
sync();
|
||||
|
||||
+106
@@ -0,0 +1,106 @@
|
||||
/* vi: set sw=4 ts=4: */
|
||||
/*
|
||||
* tac implementation for busybox
|
||||
*
|
||||
* Copyright (C) 2003 Yang Xiaopeng <yxp at hanwang.com.cn>
|
||||
* Copyright (C) 2007 Natanael Copa <natanael.copa@gmail.com>
|
||||
* Copyright (C) 2007 Tito Ragusa <farmatito@tiscali.it>
|
||||
*
|
||||
* Licensed under GPLv2, see file License in this tarball for details.
|
||||
*
|
||||
*/
|
||||
|
||||
/* tac - concatenate and print files in reverse */
|
||||
|
||||
/* Based on Yang Xiaopeng's (yxp at hanwang.com.cn) patch
|
||||
* http://www.uclibc.org/lists/busybox/2003-July/008813.html
|
||||
*/
|
||||
|
||||
#include "libbb.h"
|
||||
|
||||
/* This is a NOEXEC applet. Be very careful! */
|
||||
|
||||
struct lstring {
|
||||
int size;
|
||||
char buf[1];
|
||||
};
|
||||
|
||||
int tac_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int tac_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
char **name;
|
||||
FILE *f;
|
||||
struct lstring *line = NULL;
|
||||
llist_t *list = NULL;
|
||||
int retval = EXIT_SUCCESS;
|
||||
|
||||
#if ENABLE_DESKTOP
|
||||
/* tac from coreutils 6.9 supports:
|
||||
-b, --before
|
||||
attach the separator before instead of after
|
||||
-r, --regex
|
||||
interpret the separator as a regular expression
|
||||
-s, --separator=STRING
|
||||
use STRING as the separator instead of newline
|
||||
We support none, but at least we will complain or handle "--":
|
||||
*/
|
||||
getopt32(argv, "");
|
||||
argv += optind;
|
||||
#else
|
||||
argv++;
|
||||
#endif
|
||||
if (!*argv)
|
||||
*--argv = (char *)"-";
|
||||
/* We will read from last file to first */
|
||||
name = argv;
|
||||
while (*name)
|
||||
name++;
|
||||
|
||||
do {
|
||||
int ch, i;
|
||||
|
||||
name--;
|
||||
f = fopen_or_warn_stdin(*name);
|
||||
if (f == NULL) {
|
||||
/* error message is printed by fopen_or_warn_stdin */
|
||||
retval = EXIT_FAILURE;
|
||||
continue;
|
||||
}
|
||||
|
||||
errno = i = 0;
|
||||
do {
|
||||
ch = fgetc(f);
|
||||
if (ch != EOF) {
|
||||
if (!(i & 0x7f))
|
||||
/* Grow on every 128th char */
|
||||
line = xrealloc(line, i + 0x7f + sizeof(int) + 1);
|
||||
line->buf[i++] = ch;
|
||||
}
|
||||
if (ch == '\n' || (ch == EOF && i != 0)) {
|
||||
line = xrealloc(line, i + sizeof(int));
|
||||
line->size = i;
|
||||
llist_add_to(&list, line);
|
||||
line = NULL;
|
||||
i = 0;
|
||||
}
|
||||
} while (ch != EOF);
|
||||
/* fgetc sets errno to ENOENT on EOF, we don't want
|
||||
* to warn on this non-error! */
|
||||
if (errno && errno != ENOENT) {
|
||||
bb_simple_perror_msg(*name);
|
||||
retval = EXIT_FAILURE;
|
||||
}
|
||||
} while (name != argv);
|
||||
|
||||
while (list) {
|
||||
line = (struct lstring *)list->data;
|
||||
xwrite(STDOUT_FILENO, line->buf, line->size);
|
||||
if (ENABLE_FEATURE_CLEAN_UP) {
|
||||
free(llist_pop(&list));
|
||||
} else {
|
||||
list = list->link;
|
||||
}
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
+50
-54
@@ -74,7 +74,7 @@ static unsigned eat_num(const char *p)
|
||||
p++;
|
||||
else if (*p == '+') {
|
||||
p++;
|
||||
G.status = EXIT_FAILURE;
|
||||
G.status = 1; /* mark that we saw "+" */
|
||||
}
|
||||
return xatou_sfx(p, tail_suffixes);
|
||||
}
|
||||
@@ -87,12 +87,11 @@ int tail_main(int argc, char **argv)
|
||||
bool from_top;
|
||||
int header_threshhold = 1;
|
||||
const char *str_c, *str_n;
|
||||
USE_FEATURE_FANCY_TAIL(const char *str_s;)
|
||||
|
||||
char *tailbuf;
|
||||
size_t tailbufsize;
|
||||
int taillen = 0;
|
||||
int newline = 0;
|
||||
int newlines_seen = 0;
|
||||
int nfiles, nread, nwrite, seen, i, opt;
|
||||
|
||||
int *fds;
|
||||
@@ -101,21 +100,18 @@ int tail_main(int argc, char **argv)
|
||||
|
||||
#if ENABLE_INCLUDE_SUSv2 || ENABLE_FEATURE_FANCY_TAIL
|
||||
/* Allow legacy syntax of an initial numeric option without -n. */
|
||||
if (argc >= 2 && (argv[1][0] == '+' || argv[1][0] == '-')
|
||||
if (argv[1] && (argv[1][0] == '+' || argv[1][0] == '-')
|
||||
&& isdigit(argv[1][1])
|
||||
) {
|
||||
/* replacing arg[0] with "-n" can segfault, so... */
|
||||
argv[1] = xasprintf("-n%s", argv[1]);
|
||||
#if 0 /* If we ever decide to make tail NOFORK */
|
||||
char *s = alloca(strlen(argv[1]) + 3);
|
||||
sprintf(s, "-n%s", argv[1]);
|
||||
argv[1] = s;
|
||||
#endif
|
||||
count = eat_num(&argv[1][1]);
|
||||
argv++;
|
||||
argc--;
|
||||
}
|
||||
#endif
|
||||
|
||||
USE_FEATURE_FANCY_TAIL(opt_complementary = "s+";) /* -s N */
|
||||
opt = getopt32(argv, "fc:n:" USE_FEATURE_FANCY_TAIL("qs:v"),
|
||||
&str_c, &str_n USE_FEATURE_FANCY_TAIL(,&str_s));
|
||||
&str_c, &str_n USE_FEATURE_FANCY_TAIL(,&sleep_period));
|
||||
#define FOLLOW (opt & 0x1)
|
||||
#define COUNT_BYTES (opt & 0x2)
|
||||
//if (opt & 0x1) // -f
|
||||
@@ -123,18 +119,16 @@ int tail_main(int argc, char **argv)
|
||||
if (opt & 0x4) count = eat_num(str_n); // -n
|
||||
#if ENABLE_FEATURE_FANCY_TAIL
|
||||
if (opt & 0x8) header_threshhold = INT_MAX; // -q
|
||||
if (opt & 0x10) sleep_period = xatou(str_s); // -s
|
||||
if (opt & 0x20) header_threshhold = 0; // -v
|
||||
#endif
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
from_top = G.status;
|
||||
from_top = G.status; /* 1 if there was "-c +N" or "-n +N" */
|
||||
G.status = EXIT_SUCCESS;
|
||||
|
||||
/* open all the files */
|
||||
fds = xmalloc(sizeof(int) * (argc + 1));
|
||||
nfiles = i = 0;
|
||||
G.status = EXIT_SUCCESS;
|
||||
if (argc == 0) {
|
||||
if (!argv[0]) {
|
||||
struct stat statbuf;
|
||||
|
||||
if (!fstat(STDIN_FILENO, &statbuf) && S_ISFIFO(statbuf.st_mode)) {
|
||||
@@ -142,52 +136,59 @@ int tail_main(int argc, char **argv)
|
||||
}
|
||||
*argv = (char *) bb_msg_standard_input;
|
||||
}
|
||||
nfiles = i = 0;
|
||||
do {
|
||||
FILE* fil = fopen_or_warn_stdin(argv[i]);
|
||||
if (!fil) {
|
||||
int fd = open_or_warn_stdin(argv[i]);
|
||||
if (fd < 0) {
|
||||
G.status = EXIT_FAILURE;
|
||||
continue;
|
||||
}
|
||||
fds[nfiles] = fileno(fil);
|
||||
fds[nfiles] = fd;
|
||||
argv[nfiles++] = argv[i];
|
||||
} while (++i < argc);
|
||||
|
||||
if (!nfiles)
|
||||
bb_error_msg_and_die("no files");
|
||||
|
||||
/* prepare the buffer */
|
||||
tailbufsize = BUFSIZ;
|
||||
|
||||
/* tail the files */
|
||||
if (!from_top && COUNT_BYTES) {
|
||||
if (tailbufsize < count) {
|
||||
if (tailbufsize < count + BUFSIZ) {
|
||||
tailbufsize = count + BUFSIZ;
|
||||
}
|
||||
}
|
||||
tailbuf = xmalloc(tailbufsize);
|
||||
|
||||
buf = tailbuf = xmalloc(tailbufsize);
|
||||
|
||||
/* tail the files */
|
||||
fmt = header_fmt + 1; /* Skip header leading newline on first output. */
|
||||
i = 0;
|
||||
do {
|
||||
/* Be careful. It would be possible to optimize the count-bytes
|
||||
* case if the file is seekable. If you do though, remember that
|
||||
* starting file position may not be the beginning of the file.
|
||||
* Beware of backing up too far. See example in wc.c.
|
||||
*/
|
||||
if (!(count | from_top) && lseek(fds[i], 0, SEEK_END) >= 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (nfiles > header_threshhold) {
|
||||
tail_xprint_header(fmt, argv[i]);
|
||||
fmt = header_fmt;
|
||||
}
|
||||
|
||||
/* Optimizing count-bytes case if the file is seekable.
|
||||
* Beware of backing up too far.
|
||||
* Also we exclude files with size 0 (because of /proc/xxx) */
|
||||
if (COUNT_BYTES && !from_top) {
|
||||
off_t current = lseek(fds[i], 0, SEEK_END);
|
||||
if (current > 0) {
|
||||
if (count == 0)
|
||||
continue; /* showing zero lines is easy :) */
|
||||
current -= count;
|
||||
if (current < 0)
|
||||
current = 0;
|
||||
xlseek(fds[i], current, SEEK_SET);
|
||||
bb_copyfd_size(fds[i], STDOUT_FILENO, count);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
buf = tailbuf;
|
||||
taillen = 0;
|
||||
seen = 1;
|
||||
newline = 0;
|
||||
|
||||
newlines_seen = 0;
|
||||
while ((nread = tail_read(fds[i], buf, tailbufsize-taillen)) > 0) {
|
||||
if (from_top) {
|
||||
nwrite = nread;
|
||||
@@ -215,34 +216,32 @@ int tail_main(int argc, char **argv)
|
||||
}
|
||||
} else {
|
||||
int k = nread;
|
||||
int nbuf = 0;
|
||||
int newlines_in_buf = 0;
|
||||
|
||||
while (k) {
|
||||
--k;
|
||||
do { /* count '\n' in last read */
|
||||
k--;
|
||||
if (buf[k] == '\n') {
|
||||
++nbuf;
|
||||
newlines_in_buf++;
|
||||
}
|
||||
}
|
||||
} while (k);
|
||||
|
||||
if (newline + nbuf < count) {
|
||||
newline += nbuf;
|
||||
if (newlines_seen + newlines_in_buf < count) {
|
||||
newlines_seen += newlines_in_buf;
|
||||
taillen += nread;
|
||||
} else {
|
||||
int extra = 0;
|
||||
int extra = (buf[nread-1] != '\n');
|
||||
|
||||
if (buf[nread-1] != '\n')
|
||||
extra = 1;
|
||||
k = newline + nbuf + extra - count;
|
||||
k = newlines_seen + newlines_in_buf + extra - count;
|
||||
s = tailbuf;
|
||||
while (k) {
|
||||
if (*s == '\n') {
|
||||
--k;
|
||||
k--;
|
||||
}
|
||||
++s;
|
||||
s++;
|
||||
}
|
||||
taillen += nread - (s - tailbuf);
|
||||
memmove(tailbuf, s, taillen);
|
||||
newline = count - extra;
|
||||
newlines_seen = count - extra;
|
||||
}
|
||||
if (tailbufsize < taillen + BUFSIZ) {
|
||||
tailbufsize = taillen + BUFSIZ;
|
||||
@@ -251,13 +250,10 @@ int tail_main(int argc, char **argv)
|
||||
}
|
||||
buf = tailbuf + taillen;
|
||||
}
|
||||
}
|
||||
|
||||
} /* while (tail_read() > 0) */
|
||||
if (!from_top) {
|
||||
xwrite(STDOUT_FILENO, tailbuf, taillen);
|
||||
}
|
||||
|
||||
taillen = 0;
|
||||
} while (++i < nfiles);
|
||||
|
||||
buf = xrealloc(tailbuf, BUFSIZ);
|
||||
|
||||
+2
-2
@@ -36,12 +36,12 @@ int tee_main(int argc, char **argv)
|
||||
mode += (retval & 2); /* Since 'a' is the 2nd option... */
|
||||
|
||||
if (retval & 1) {
|
||||
signal(SIGINT, SIG_IGN); /* TODO - switch to sigaction. */
|
||||
signal(SIGINT, SIG_IGN); /* TODO - switch to sigaction. (why?) */
|
||||
}
|
||||
retval = EXIT_SUCCESS;
|
||||
/* gnu tee ignores SIGPIPE in case one of the output files is a pipe
|
||||
* that doesn't consume all its input. Good idea... */
|
||||
signal(SIGPIPE, SIG_IGN); /* TODO - switch to sigaction. */
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
|
||||
/* Allocate an array of FILE *'s, with one extra for a sentinal. */
|
||||
fp = files = xzalloc(sizeof(FILE *) * (argc + 2));
|
||||
|
||||
+315
-276
@@ -23,7 +23,11 @@
|
||||
#include "libbb.h"
|
||||
#include <setjmp.h>
|
||||
|
||||
/* This is a NOEXEC applet. Be very careful! */
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
/* test_main() is called from shells, and we need to be extra careful here.
|
||||
* This is true regardless of PREFER_APPLETS and STANDALONE_SHELL
|
||||
* state. */
|
||||
|
||||
|
||||
/* test(1) accepts the following grammar:
|
||||
@@ -85,12 +89,12 @@ enum token {
|
||||
RPAREN,
|
||||
OPERAND
|
||||
};
|
||||
#define is_int_op(a) (((unsigned char)((a) - INTEQ)) <= 5)
|
||||
#define is_str_op(a) (((unsigned char)((a) - STREZ)) <= 5)
|
||||
#define is_file_op(a) (((unsigned char)((a) - FILNT)) <= 2)
|
||||
#define is_int_op(a) (((unsigned char)((a) - INTEQ)) <= 5)
|
||||
#define is_str_op(a) (((unsigned char)((a) - STREZ)) <= 5)
|
||||
#define is_file_op(a) (((unsigned char)((a) - FILNT)) <= 2)
|
||||
#define is_file_access(a) (((unsigned char)((a) - FILRD)) <= 2)
|
||||
#define is_file_type(a) (((unsigned char)((a) - FILREG)) <= 5)
|
||||
#define is_file_bit(a) (((unsigned char)((a) - FILSUID)) <= 2)
|
||||
#define is_file_type(a) (((unsigned char)((a) - FILREG)) <= 5)
|
||||
#define is_file_bit(a) (((unsigned char)((a) - FILSUID)) <= 2)
|
||||
enum token_types {
|
||||
UNOP,
|
||||
BINOP,
|
||||
@@ -153,98 +157,36 @@ typedef int64_t arith_t;
|
||||
typedef int arith_t;
|
||||
#endif
|
||||
|
||||
/* Cannot eliminate these static data (do the G trick)
|
||||
* because of test_main usage from other applets */
|
||||
static char **t_wp;
|
||||
static const struct t_op *t_wp_op;
|
||||
static gid_t *group_array;
|
||||
static int ngroups;
|
||||
static jmp_buf leaving;
|
||||
|
||||
static enum token t_lex(char *s);
|
||||
static arith_t oexpr(enum token n);
|
||||
static arith_t aexpr(enum token n);
|
||||
static arith_t nexpr(enum token n);
|
||||
static int binop(void);
|
||||
/* We try to minimize both static and stack usage. */
|
||||
struct statics {
|
||||
char **t_wp;
|
||||
const struct t_op *t_wp_op;
|
||||
gid_t *group_array;
|
||||
int ngroups;
|
||||
jmp_buf leaving;
|
||||
};
|
||||
|
||||
/* Make it reside in writable memory, yet make compiler understand
|
||||
* that it is not going to change. */
|
||||
static struct statics *const ptr_to_statics __attribute__ ((section (".data")));
|
||||
|
||||
#define S (*ptr_to_statics)
|
||||
#define t_wp (S.t_wp )
|
||||
#define t_wp_op (S.t_wp_op )
|
||||
#define group_array (S.group_array )
|
||||
#define ngroups (S.ngroups )
|
||||
#define leaving (S.leaving )
|
||||
|
||||
#define INIT_S() do { \
|
||||
(*(struct statics**)&ptr_to_statics) = xzalloc(sizeof(S)); \
|
||||
barrier(); \
|
||||
} while (0)
|
||||
#define DEINIT_S() do { \
|
||||
free(ptr_to_statics); \
|
||||
} while (0)
|
||||
|
||||
static arith_t primary(enum token n);
|
||||
static int filstat(char *nm, enum token mode);
|
||||
static arith_t getn(const char *s);
|
||||
/* UNUSED
|
||||
static int newerf(const char *f1, const char *f2);
|
||||
static int olderf(const char *f1, const char *f2);
|
||||
static int equalf(const char *f1, const char *f2);
|
||||
*/
|
||||
static int test_eaccess(char *path, int mode);
|
||||
static int is_a_group_member(gid_t gid);
|
||||
static void initialize_group_array(void);
|
||||
|
||||
int test_main(int argc, char **argv)
|
||||
{
|
||||
int res;
|
||||
const char *arg0;
|
||||
bool _off;
|
||||
|
||||
arg0 = bb_basename(argv[0]);
|
||||
if (arg0[0] == '[') {
|
||||
--argc;
|
||||
if (!arg0[1]) { /* "[" ? */
|
||||
if (NOT_LONE_CHAR(argv[argc], ']')) {
|
||||
bb_error_msg("missing ]");
|
||||
return 2;
|
||||
}
|
||||
} else { /* assuming "[[" */
|
||||
if (strcmp(argv[argc], "]]") != 0) {
|
||||
bb_error_msg("missing ]]");
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
argv[argc] = NULL;
|
||||
}
|
||||
|
||||
res = setjmp(leaving);
|
||||
if (res)
|
||||
return res;
|
||||
|
||||
/* resetting ngroups is probably unnecessary. it will
|
||||
* force a new call to getgroups(), which prevents using
|
||||
* group data fetched during a previous call. but the
|
||||
* only way the group data could be stale is if there's
|
||||
* been an intervening call to setgroups(), and this
|
||||
* isn't likely in the case of a shell. paranoia
|
||||
* prevails...
|
||||
*/
|
||||
ngroups = 0;
|
||||
|
||||
/* Implement special cases from POSIX.2, section 4.62.4 */
|
||||
if (argc == 1)
|
||||
return 1;
|
||||
if (argc == 2)
|
||||
return *argv[1] == '\0';
|
||||
//assert(argc);
|
||||
/* remember if we saw argc==4 which wants *no* '!' test */
|
||||
_off = argc - 4;
|
||||
if (_off ?
|
||||
(LONE_CHAR(argv[1], '!'))
|
||||
: (argv[1][0] != '!' || argv[1][1] != '\0'))
|
||||
{
|
||||
if (argc == 3)
|
||||
return *argv[2] != '\0';
|
||||
|
||||
t_lex(argv[2 + _off]);
|
||||
if (t_wp_op && t_wp_op->op_type == BINOP) {
|
||||
t_wp = &argv[1 + _off];
|
||||
return binop() == _off;
|
||||
}
|
||||
}
|
||||
t_wp = &argv[1];
|
||||
res = !oexpr(t_lex(*t_wp));
|
||||
|
||||
if (*t_wp != NULL && *++t_wp != NULL) {
|
||||
bb_error_msg("%s: unknown operand", *t_wp);
|
||||
return 2;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
static void syntax(const char *op, const char *msg) ATTRIBUTE_NORETURN;
|
||||
static void syntax(const char *op, const char *msg)
|
||||
@@ -257,69 +199,82 @@ static void syntax(const char *op, const char *msg)
|
||||
longjmp(leaving, 2);
|
||||
}
|
||||
|
||||
static arith_t oexpr(enum token n)
|
||||
/* atoi with error detection */
|
||||
//XXX: FIXME: duplicate of existing libbb function?
|
||||
static arith_t getn(const char *s)
|
||||
{
|
||||
arith_t res;
|
||||
char *p;
|
||||
#if ENABLE_FEATURE_TEST_64
|
||||
long long r;
|
||||
#else
|
||||
long r;
|
||||
#endif
|
||||
|
||||
res = aexpr(n);
|
||||
if (t_lex(*++t_wp) == BOR) {
|
||||
return oexpr(t_lex(*++t_wp)) || res;
|
||||
}
|
||||
t_wp--;
|
||||
return res;
|
||||
errno = 0;
|
||||
#if ENABLE_FEATURE_TEST_64
|
||||
r = strtoll(s, &p, 10);
|
||||
#else
|
||||
r = strtol(s, &p, 10);
|
||||
#endif
|
||||
|
||||
if (errno != 0)
|
||||
syntax(s, "out of range");
|
||||
|
||||
if (*(skip_whitespace(p)))
|
||||
syntax(s, "bad number");
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
static arith_t aexpr(enum token n)
|
||||
/* UNUSED
|
||||
static int newerf(const char *f1, const char *f2)
|
||||
{
|
||||
arith_t res;
|
||||
struct stat b1, b2;
|
||||
|
||||
res = nexpr(n);
|
||||
if (t_lex(*++t_wp) == BAND)
|
||||
return aexpr(t_lex(*++t_wp)) && res;
|
||||
t_wp--;
|
||||
return res;
|
||||
return (stat(f1, &b1) == 0 &&
|
||||
stat(f2, &b2) == 0 && b1.st_mtime > b2.st_mtime);
|
||||
}
|
||||
|
||||
static arith_t nexpr(enum token n)
|
||||
static int olderf(const char *f1, const char *f2)
|
||||
{
|
||||
if (n == UNOT)
|
||||
return !nexpr(t_lex(*++t_wp));
|
||||
return primary(n);
|
||||
struct stat b1, b2;
|
||||
|
||||
return (stat(f1, &b1) == 0 &&
|
||||
stat(f2, &b2) == 0 && b1.st_mtime < b2.st_mtime);
|
||||
}
|
||||
|
||||
static arith_t primary(enum token n)
|
||||
static int equalf(const char *f1, const char *f2)
|
||||
{
|
||||
arith_t res;
|
||||
struct stat b1, b2;
|
||||
|
||||
if (n == EOI) {
|
||||
syntax(NULL, "argument expected");
|
||||
}
|
||||
if (n == LPAREN) {
|
||||
res = oexpr(t_lex(*++t_wp));
|
||||
if (t_lex(*++t_wp) != RPAREN)
|
||||
syntax(NULL, "closing paren expected");
|
||||
return res;
|
||||
}
|
||||
if (t_wp_op && t_wp_op->op_type == UNOP) {
|
||||
/* unary expression */
|
||||
if (*++t_wp == NULL)
|
||||
syntax(t_wp_op->op_text, "argument expected");
|
||||
if (n == STREZ)
|
||||
return t_wp[0][0] == '\0';
|
||||
if (n == STRNZ)
|
||||
return t_wp[0][0] != '\0';
|
||||
if (n == FILTT)
|
||||
return isatty(getn(*t_wp));
|
||||
return filstat(*t_wp, n);
|
||||
}
|
||||
|
||||
t_lex(t_wp[1]);
|
||||
if (t_wp_op && t_wp_op->op_type == BINOP) {
|
||||
return binop();
|
||||
}
|
||||
|
||||
return t_wp[0][0] != '\0';
|
||||
return (stat(f1, &b1) == 0 &&
|
||||
stat(f2, &b2) == 0 &&
|
||||
b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino);
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
static enum token t_lex(char *s)
|
||||
{
|
||||
const struct t_op *op;
|
||||
|
||||
t_wp_op = NULL;
|
||||
if (s == NULL) {
|
||||
return EOI;
|
||||
}
|
||||
|
||||
op = ops;
|
||||
do {
|
||||
if (strcmp(s, op->op_text) == 0) {
|
||||
t_wp_op = op;
|
||||
return op->op_num;
|
||||
}
|
||||
op++;
|
||||
} while (op < ops + ARRAY_SIZE(ops));
|
||||
|
||||
return OPERAND;
|
||||
}
|
||||
|
||||
|
||||
static int binop(void)
|
||||
{
|
||||
@@ -381,6 +336,80 @@ static int binop(void)
|
||||
return 1; /* NOTREACHED */
|
||||
}
|
||||
|
||||
|
||||
static void initialize_group_array(void)
|
||||
{
|
||||
ngroups = getgroups(0, NULL);
|
||||
if (ngroups > 0) {
|
||||
/* FIXME: ash tries so hard to not die on OOM,
|
||||
* and we spoil it with just one xrealloc here */
|
||||
/* We realloc, because test_main can be entered repeatedly by shell.
|
||||
* Testcase (ash): 'while true; do test -x some_file; done'
|
||||
* and watch top. (some_file must have owner != you) */
|
||||
group_array = xrealloc(group_array, ngroups * sizeof(gid_t));
|
||||
getgroups(ngroups, group_array);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Return non-zero if GID is one that we have in our groups list. */
|
||||
//XXX: FIXME: duplicate of existing libbb function?
|
||||
// see toplevel TODO file:
|
||||
// possible code duplication ingroup() and is_a_group_member()
|
||||
static int is_a_group_member(gid_t gid)
|
||||
{
|
||||
int i;
|
||||
|
||||
/* Short-circuit if possible, maybe saving a call to getgroups(). */
|
||||
if (gid == getgid() || gid == getegid())
|
||||
return 1;
|
||||
|
||||
if (ngroups == 0)
|
||||
initialize_group_array();
|
||||
|
||||
/* Search through the list looking for GID. */
|
||||
for (i = 0; i < ngroups; i++)
|
||||
if (gid == group_array[i])
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* Do the same thing access(2) does, but use the effective uid and gid,
|
||||
and don't make the mistake of telling root that any file is
|
||||
executable. */
|
||||
static int test_eaccess(char *path, int mode)
|
||||
{
|
||||
struct stat st;
|
||||
unsigned int euid = geteuid();
|
||||
|
||||
if (stat(path, &st) < 0)
|
||||
return -1;
|
||||
|
||||
if (euid == 0) {
|
||||
/* Root can read or write any file. */
|
||||
if (mode != X_OK)
|
||||
return 0;
|
||||
|
||||
/* Root can execute any file that has any one of the execute
|
||||
bits set. */
|
||||
if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (st.st_uid == euid) /* owner */
|
||||
mode <<= 6;
|
||||
else if (is_a_group_member(st.st_gid))
|
||||
mode <<= 3;
|
||||
|
||||
if (st.st_mode & mode)
|
||||
return 0;
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
static int filstat(char *nm, enum token mode)
|
||||
{
|
||||
struct stat s;
|
||||
@@ -453,147 +482,157 @@ static int filstat(char *nm, enum token mode)
|
||||
return 1; /* NOTREACHED */
|
||||
}
|
||||
|
||||
static enum token t_lex(char *s)
|
||||
{
|
||||
const struct t_op *op;
|
||||
|
||||
t_wp_op = NULL;
|
||||
if (s == NULL) {
|
||||
return EOI;
|
||||
static arith_t nexpr(enum token n)
|
||||
{
|
||||
if (n == UNOT)
|
||||
return !nexpr(t_lex(*++t_wp));
|
||||
return primary(n);
|
||||
}
|
||||
|
||||
|
||||
static arith_t aexpr(enum token n)
|
||||
{
|
||||
arith_t res;
|
||||
|
||||
res = nexpr(n);
|
||||
if (t_lex(*++t_wp) == BAND)
|
||||
return aexpr(t_lex(*++t_wp)) && res;
|
||||
t_wp--;
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
static arith_t oexpr(enum token n)
|
||||
{
|
||||
arith_t res;
|
||||
|
||||
res = aexpr(n);
|
||||
if (t_lex(*++t_wp) == BOR) {
|
||||
return oexpr(t_lex(*++t_wp)) || res;
|
||||
}
|
||||
t_wp--;
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static arith_t primary(enum token n)
|
||||
{
|
||||
arith_t res;
|
||||
|
||||
if (n == EOI) {
|
||||
syntax(NULL, "argument expected");
|
||||
}
|
||||
if (n == LPAREN) {
|
||||
res = oexpr(t_lex(*++t_wp));
|
||||
if (t_lex(*++t_wp) != RPAREN)
|
||||
syntax(NULL, "closing paren expected");
|
||||
return res;
|
||||
}
|
||||
if (t_wp_op && t_wp_op->op_type == UNOP) {
|
||||
/* unary expression */
|
||||
if (*++t_wp == NULL)
|
||||
syntax(t_wp_op->op_text, "argument expected");
|
||||
if (n == STREZ)
|
||||
return t_wp[0][0] == '\0';
|
||||
if (n == STRNZ)
|
||||
return t_wp[0][0] != '\0';
|
||||
if (n == FILTT)
|
||||
return isatty(getn(*t_wp));
|
||||
return filstat(*t_wp, n);
|
||||
}
|
||||
|
||||
op = ops;
|
||||
do {
|
||||
if (strcmp(s, op->op_text) == 0) {
|
||||
t_wp_op = op;
|
||||
return op->op_num;
|
||||
t_lex(t_wp[1]);
|
||||
if (t_wp_op && t_wp_op->op_type == BINOP) {
|
||||
return binop();
|
||||
}
|
||||
|
||||
return t_wp[0][0] != '\0';
|
||||
}
|
||||
|
||||
|
||||
int test_main(int argc, char **argv)
|
||||
{
|
||||
int res;
|
||||
const char *arg0;
|
||||
bool negate = 0;
|
||||
|
||||
arg0 = bb_basename(argv[0]);
|
||||
if (arg0[0] == '[') {
|
||||
--argc;
|
||||
if (!arg0[1]) { /* "[" ? */
|
||||
if (NOT_LONE_CHAR(argv[argc], ']')) {
|
||||
bb_error_msg("missing ]");
|
||||
return 2;
|
||||
}
|
||||
} else { /* assuming "[[" */
|
||||
if (strcmp(argv[argc], "]]") != 0) {
|
||||
bb_error_msg("missing ]]");
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
op++;
|
||||
} while (op < ops + ARRAY_SIZE(ops));
|
||||
|
||||
return OPERAND;
|
||||
}
|
||||
|
||||
/* atoi with error detection */
|
||||
//XXX: FIXME: duplicate of existing libbb function?
|
||||
static arith_t getn(const char *s)
|
||||
{
|
||||
char *p;
|
||||
#if ENABLE_FEATURE_TEST_64
|
||||
long long r;
|
||||
#else
|
||||
long r;
|
||||
#endif
|
||||
|
||||
errno = 0;
|
||||
#if ENABLE_FEATURE_TEST_64
|
||||
r = strtoll(s, &p, 10);
|
||||
#else
|
||||
r = strtol(s, &p, 10);
|
||||
#endif
|
||||
|
||||
if (errno != 0)
|
||||
syntax(s, "out of range");
|
||||
|
||||
if (*(skip_whitespace(p)))
|
||||
syntax(s, "bad number");
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
/* UNUSED
|
||||
static int newerf(const char *f1, const char *f2)
|
||||
{
|
||||
struct stat b1, b2;
|
||||
|
||||
return (stat(f1, &b1) == 0 &&
|
||||
stat(f2, &b2) == 0 && b1.st_mtime > b2.st_mtime);
|
||||
}
|
||||
|
||||
static int olderf(const char *f1, const char *f2)
|
||||
{
|
||||
struct stat b1, b2;
|
||||
|
||||
return (stat(f1, &b1) == 0 &&
|
||||
stat(f2, &b2) == 0 && b1.st_mtime < b2.st_mtime);
|
||||
}
|
||||
|
||||
static int equalf(const char *f1, const char *f2)
|
||||
{
|
||||
struct stat b1, b2;
|
||||
|
||||
return (stat(f1, &b1) == 0 &&
|
||||
stat(f2, &b2) == 0 &&
|
||||
b1.st_dev == b2.st_dev && b1.st_ino == b2.st_ino);
|
||||
}
|
||||
*/
|
||||
|
||||
/* Do the same thing access(2) does, but use the effective uid and gid,
|
||||
and don't make the mistake of telling root that any file is
|
||||
executable. */
|
||||
static int test_eaccess(char *path, int mode)
|
||||
{
|
||||
struct stat st;
|
||||
unsigned int euid = geteuid();
|
||||
|
||||
if (stat(path, &st) < 0)
|
||||
return -1;
|
||||
|
||||
if (euid == 0) {
|
||||
/* Root can read or write any file. */
|
||||
if (mode != X_OK)
|
||||
return 0;
|
||||
|
||||
/* Root can execute any file that has any one of the execute
|
||||
bits set. */
|
||||
if (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
|
||||
return 0;
|
||||
argv[argc] = NULL;
|
||||
}
|
||||
|
||||
if (st.st_uid == euid) /* owner */
|
||||
mode <<= 6;
|
||||
else if (is_a_group_member(st.st_gid))
|
||||
mode <<= 3;
|
||||
/* We must do DEINIT_S() prior to returning */
|
||||
INIT_S();
|
||||
|
||||
if (st.st_mode & mode)
|
||||
return 0;
|
||||
res = setjmp(leaving);
|
||||
if (res)
|
||||
goto ret;
|
||||
|
||||
return -1;
|
||||
}
|
||||
/* resetting ngroups is probably unnecessary. it will
|
||||
* force a new call to getgroups(), which prevents using
|
||||
* group data fetched during a previous call. but the
|
||||
* only way the group data could be stale is if there's
|
||||
* been an intervening call to setgroups(), and this
|
||||
* isn't likely in the case of a shell. paranoia
|
||||
* prevails...
|
||||
*/
|
||||
ngroups = 0;
|
||||
|
||||
static void initialize_group_array(void)
|
||||
{
|
||||
ngroups = getgroups(0, NULL);
|
||||
if (ngroups > 0) {
|
||||
/* FIXME: ash tries so hard to not die on OOM,
|
||||
* and we spoil it with just one xrealloc here */
|
||||
/* We realloc, because test_main can be entered repeatedly by shell.
|
||||
* Testcase (ash): 'while true; do test -x some_file; done'
|
||||
* and watch top. (some_file must have owner != you) */
|
||||
group_array = xrealloc(group_array, ngroups * sizeof(gid_t));
|
||||
getgroups(ngroups, group_array);
|
||||
//argc--;
|
||||
argv++;
|
||||
|
||||
/* Implement special cases from POSIX.2, section 4.62.4 */
|
||||
if (!argv[0]) { /* "test" */
|
||||
res = 1;
|
||||
goto ret;
|
||||
}
|
||||
if (LONE_CHAR(argv[0], '!') && argv[1]) {
|
||||
negate = 1;
|
||||
//argc--;
|
||||
argv++;
|
||||
}
|
||||
if (!argv[1]) { /* "test [!] arg" */
|
||||
res = (*argv[0] == '\0');
|
||||
goto ret;
|
||||
}
|
||||
if (argv[2] && !argv[3]) {
|
||||
t_lex(argv[1]);
|
||||
if (t_wp_op && t_wp_op->op_type == BINOP) {
|
||||
/* "test [!] arg1 <binary_op> arg2" */
|
||||
t_wp = &argv[0];
|
||||
res = (binop() == 0);
|
||||
goto ret;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Return non-zero if GID is one that we have in our groups list. */
|
||||
//XXX: FIXME: duplicate of existing libbb function?
|
||||
// see toplevel TODO file:
|
||||
// possible code duplication ingroup() and is_a_group_member()
|
||||
static int is_a_group_member(gid_t gid)
|
||||
{
|
||||
int i;
|
||||
/* Some complex expression. Undo '!' removal */
|
||||
if (negate) {
|
||||
negate = 0;
|
||||
//argc++;
|
||||
argv--;
|
||||
}
|
||||
t_wp = &argv[0];
|
||||
res = !oexpr(t_lex(*t_wp));
|
||||
|
||||
/* Short-circuit if possible, maybe saving a call to getgroups(). */
|
||||
if (gid == getgid() || gid == getegid())
|
||||
return 1;
|
||||
|
||||
if (ngroups == 0)
|
||||
initialize_group_array();
|
||||
|
||||
/* Search through the list looking for GID. */
|
||||
for (i = 0; i < ngroups; i++)
|
||||
if (gid == group_array[i])
|
||||
return 1;
|
||||
|
||||
return 0;
|
||||
if (*t_wp != NULL && *++t_wp != NULL) {
|
||||
bb_error_msg("%s: unknown operand", *t_wp);
|
||||
res = 2;
|
||||
}
|
||||
ret:
|
||||
DEINIT_S();
|
||||
return negate ? !res : res;
|
||||
}
|
||||
+3
-2
@@ -22,12 +22,13 @@
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
int touch_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int touch_main(int argc, char **argv)
|
||||
int touch_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
int fd;
|
||||
int status = EXIT_SUCCESS;
|
||||
int flags = getopt32(argv, "c");
|
||||
int flags = getopt32(argv, "cf");
|
||||
|
||||
flags &= 1; /* ignoring -f (BSD compat thingy) */
|
||||
argv += optind;
|
||||
|
||||
if (!*argv) {
|
||||
|
||||
+80
-77
@@ -22,10 +22,6 @@
|
||||
|
||||
#define ASCII 0377
|
||||
|
||||
#define TR_OPT_complement (1<<0)
|
||||
#define TR_OPT_delete (1<<1)
|
||||
#define TR_OPT_squeeze_reps (1<<2)
|
||||
|
||||
static void map(char *pvector,
|
||||
unsigned char *string1, unsigned int string1_len,
|
||||
unsigned char *string2, unsigned int string2_len)
|
||||
@@ -42,19 +38,46 @@ static void map(char *pvector,
|
||||
}
|
||||
|
||||
/* supported constructs:
|
||||
* Ranges, e.g., [0-9] ==> 0123456789
|
||||
* Escapes, e.g., \a ==> Control-G
|
||||
* Character classes, e.g. [:upper:] ==> A ... Z
|
||||
* Ranges, e.g., 0-9 ==> 0123456789
|
||||
* Ranges, e.g., [0-9] ==> 0123456789
|
||||
* Escapes, e.g., \a ==> Control-G
|
||||
* Character classes, e.g. [:upper:] ==> A...Z
|
||||
* Equiv classess, e.g. [=A=] ==> A (hmmmmmmm?)
|
||||
*/
|
||||
static unsigned int expand(const char *arg, char *buffer)
|
||||
{
|
||||
char *buffer_start = buffer;
|
||||
unsigned i; /* XXX: FIXME: use unsigned char? */
|
||||
unsigned i; /* can't be unsigned char: must be able to hold 256 */
|
||||
unsigned char ac;
|
||||
|
||||
while (*arg) {
|
||||
if (*arg == '\\') {
|
||||
arg++;
|
||||
*buffer++ = bb_process_escape_sequence(&arg);
|
||||
continue;
|
||||
}
|
||||
if (arg[1] == '-') { /* "0-9..." */
|
||||
ac = arg[2];
|
||||
if (ac == '\0') { /* "0-": copy verbatim */
|
||||
*buffer++ = *arg++; /* copy '0' */
|
||||
continue; /* next iter will copy '-' and stop */
|
||||
}
|
||||
i = *arg;
|
||||
while (i <= ac) /* ok: i is unsigned _int_ */
|
||||
*buffer++ = i++;
|
||||
arg += 3; /* skip 0-9 */
|
||||
continue;
|
||||
}
|
||||
if (*arg == '[') { /* "[xyz..." */
|
||||
arg++;
|
||||
i = *arg++;
|
||||
/* "[xyz...", i=x, arg points to y */
|
||||
if (ENABLE_FEATURE_TR_CLASSES && i == ':') {
|
||||
#define CLO ":]\0"
|
||||
static const char classes[] ALIGN1 =
|
||||
"alpha"CLO "alnum"CLO "digit"CLO "lower"CLO "upper"CLO "space"CLO
|
||||
"blank"CLO "punct"CLO "cntrl"CLO;
|
||||
static const char classes[] ALIGN1 =
|
||||
"alpha"CLO "alnum"CLO "digit"CLO
|
||||
"lower"CLO "upper"CLO "space"CLO
|
||||
"blank"CLO "punct"CLO "cntrl"CLO;
|
||||
#define CLASS_invalid 0 /* we increment the retval */
|
||||
#define CLASS_alpha 1
|
||||
#define CLASS_alnum 2
|
||||
@@ -68,27 +91,9 @@ static unsigned int expand(const char *arg, char *buffer)
|
||||
//#define CLASS_xdigit 10
|
||||
//#define CLASS_graph 11
|
||||
//#define CLASS_print 12
|
||||
while (*arg) {
|
||||
if (*arg == '\\') {
|
||||
arg++;
|
||||
*buffer++ = bb_process_escape_sequence(&arg);
|
||||
} else if (*(arg+1) == '-') {
|
||||
ac = *(arg+2);
|
||||
if (ac == 0) {
|
||||
*buffer++ = *arg++;
|
||||
continue;
|
||||
}
|
||||
i = *arg;
|
||||
while (i <= ac)
|
||||
*buffer++ = i++;
|
||||
arg += 3; /* Skip the assumed a-z */
|
||||
} else if (*arg == '[') {
|
||||
arg++;
|
||||
i = *arg++;
|
||||
if (ENABLE_FEATURE_TR_CLASSES && i == ':') {
|
||||
smalluint j;
|
||||
{ /* not really pretty.. */
|
||||
char *tmp = xstrndup(arg, 7); // warning: xdigit needs 8, not 7
|
||||
char *tmp = xstrndup(arg, 7); // warning: xdigit would need 8, not 7
|
||||
j = index_in_strings(classes, tmp) + 1;
|
||||
free(tmp);
|
||||
}
|
||||
@@ -115,10 +120,9 @@ static unsigned int expand(const char *arg, char *buffer)
|
||||
*buffer++ = ' ';
|
||||
}
|
||||
if (j == CLASS_punct || j == CLASS_cntrl) {
|
||||
for (i = 0; i <= ASCII; i++)
|
||||
if ((j == CLASS_punct &&
|
||||
isprint(i) && (!isalnum(i)) && (!isspace(i))) ||
|
||||
(j == CLASS_cntrl && iscntrl(i)))
|
||||
for (i = '\0'; i <= ASCII; i++)
|
||||
if ((j == CLASS_punct && isprint(i) && !isalnum(i) && !isspace(i))
|
||||
|| (j == CLASS_cntrl && iscntrl(i)))
|
||||
*buffer++ = i;
|
||||
}
|
||||
if (j == CLASS_invalid) {
|
||||
@@ -128,22 +132,26 @@ static unsigned int expand(const char *arg, char *buffer)
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (ENABLE_FEATURE_TR_EQUIV && i == '=') {
|
||||
*buffer++ = *arg;
|
||||
arg += 3; /* Skip the closing =] */
|
||||
/* "[xyz...", i=x, arg points to y */
|
||||
if (ENABLE_FEATURE_TR_EQUIV && i == '=') { /* [=CHAR=] */
|
||||
*buffer++ = *arg; /* copy CHAR */
|
||||
arg += 3; /* skip CHAR=] */
|
||||
continue;
|
||||
}
|
||||
if (*arg++ != '-') {
|
||||
if (*arg != '-') { /* not [x-...] - copy verbatim */
|
||||
*buffer++ = '[';
|
||||
arg -= 2;
|
||||
continue;
|
||||
arg--; /* points to x */
|
||||
continue; /* copy all, including eventual ']' */
|
||||
}
|
||||
/* [x-y...] */
|
||||
arg++;
|
||||
ac = *arg++;
|
||||
while (i <= ac)
|
||||
*buffer++ = i++;
|
||||
arg++; /* Skip the assumed ']' */
|
||||
} else
|
||||
*buffer++ = *arg++;
|
||||
arg++; /* skip the assumed ']' */
|
||||
continue;
|
||||
}
|
||||
*buffer++ = *arg++;
|
||||
}
|
||||
return (buffer - buffer_start);
|
||||
}
|
||||
@@ -154,7 +162,7 @@ static int complement(char *buffer, int buffer_len)
|
||||
char conv[ASCII + 2];
|
||||
|
||||
ix = 0;
|
||||
for (i = 0; i <= ASCII; i++) {
|
||||
for (i = '\0'; i <= ASCII; i++) {
|
||||
for (j = 0; j < buffer_len; j++)
|
||||
if (buffer[j] == i)
|
||||
break;
|
||||
@@ -166,46 +174,41 @@ static int complement(char *buffer, int buffer_len)
|
||||
}
|
||||
|
||||
int tr_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int tr_main(int argc, char **argv)
|
||||
int tr_main(int argc ATTRIBUTE_UNUSED, char **argv)
|
||||
{
|
||||
unsigned char *ptr;
|
||||
int output_length = 0, input_length;
|
||||
int idx = 1;
|
||||
int i;
|
||||
smalluint flags = 0;
|
||||
size_t read_chars = 0, in_index = 0, out_index = 0, c, coded, last = -1;
|
||||
RESERVE_CONFIG_UBUFFER(output, BUFSIZ);
|
||||
RESERVE_CONFIG_BUFFER(vector, ASCII+1);
|
||||
RESERVE_CONFIG_BUFFER(invec, ASCII+1);
|
||||
RESERVE_CONFIG_BUFFER(outvec, ASCII+1);
|
||||
smalluint flags;
|
||||
ssize_t read_chars = 0;
|
||||
size_t in_index = 0, out_index = 0;
|
||||
unsigned last = UCHAR_MAX + 1; /* not equal to any char */
|
||||
unsigned char coded, c;
|
||||
unsigned char *output = xmalloc(BUFSIZ);
|
||||
char *vector = xzalloc((ASCII+1) * 3);
|
||||
char *invec = vector + (ASCII+1);
|
||||
char *outvec = vector + (ASCII+1) * 2;
|
||||
|
||||
#define TR_OPT_complement (1 << 0)
|
||||
#define TR_OPT_delete (1 << 1)
|
||||
#define TR_OPT_squeeze_reps (1 << 2)
|
||||
|
||||
flags = getopt32(argv, "+cds"); /* '+': stop at first non-option */
|
||||
argv += optind;
|
||||
|
||||
if (argc > 1 && argv[idx][0] == '-') {
|
||||
for (ptr = (unsigned char *) &argv[idx][1]; *ptr; ptr++) {
|
||||
if (*ptr == 'c')
|
||||
flags |= TR_OPT_complement;
|
||||
else if (*ptr == 'd')
|
||||
flags |= TR_OPT_delete;
|
||||
else if (*ptr == 's')
|
||||
flags |= TR_OPT_squeeze_reps;
|
||||
else
|
||||
bb_show_usage();
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
for (i = 0; i <= ASCII; i++) {
|
||||
vector[i] = i;
|
||||
invec[i] = outvec[i] = FALSE;
|
||||
/*invec[i] = outvec[i] = FALSE; - done by xzalloc */
|
||||
}
|
||||
|
||||
#define tr_buf bb_common_bufsiz1
|
||||
if (argv[idx] != NULL) {
|
||||
input_length = expand(argv[idx++], tr_buf);
|
||||
if (*argv != NULL) {
|
||||
input_length = expand(*argv++, tr_buf);
|
||||
if (flags & TR_OPT_complement)
|
||||
input_length = complement(tr_buf, input_length);
|
||||
if (argv[idx] != NULL) {
|
||||
if (*argv[idx] == '\0')
|
||||
if (*argv) {
|
||||
if (argv[0][0] == '\0')
|
||||
bb_error_msg_and_die("STRING2 cannot be empty");
|
||||
output_length = expand(argv[idx], output);
|
||||
output_length = expand(*argv, output);
|
||||
map(vector, tr_buf, input_length, output, output_length);
|
||||
}
|
||||
for (i = 0; i < input_length; i++)
|
||||
@@ -221,10 +224,10 @@ int tr_main(int argc, char **argv)
|
||||
xwrite(STDOUT_FILENO, (char *)output, out_index);
|
||||
out_index = 0;
|
||||
}
|
||||
read_chars = read(STDIN_FILENO, tr_buf, BUFSIZ);
|
||||
read_chars = safe_read(STDIN_FILENO, tr_buf, BUFSIZ);
|
||||
if (read_chars <= 0) {
|
||||
if (write(STDOUT_FILENO, (char *)output, out_index) != out_index)
|
||||
bb_perror_msg(bb_msg_write_error);
|
||||
if (read_chars < 0)
|
||||
bb_perror_msg_and_die(bb_msg_read_error);
|
||||
exit(EXIT_SUCCESS);
|
||||
}
|
||||
in_index = 0;
|
||||
@@ -233,8 +236,8 @@ int tr_main(int argc, char **argv)
|
||||
coded = vector[c];
|
||||
if ((flags & TR_OPT_delete) && invec[c])
|
||||
continue;
|
||||
if ((flags & TR_OPT_squeeze_reps) && last == coded &&
|
||||
(invec[c] || outvec[coded]))
|
||||
if ((flags & TR_OPT_squeeze_reps) && last == coded
|
||||
&& (invec[c] || outvec[coded]))
|
||||
continue;
|
||||
output[out_index++] = last = coded;
|
||||
}
|
||||
|
||||
+1
-1
@@ -15,7 +15,7 @@
|
||||
/* This is a NOFORK applet. Be very careful! */
|
||||
|
||||
int true_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int true_main(int argc, char **argv)
|
||||
int true_main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED)
|
||||
{
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
+5
-3
@@ -13,7 +13,7 @@
|
||||
#include "libbb.h"
|
||||
|
||||
int tty_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
||||
int tty_main(int argc, char **argv)
|
||||
int tty_main(int argc, char **argv SKIP_INCLUDE_SUSv2(ATTRIBUTE_UNUSED))
|
||||
{
|
||||
const char *s;
|
||||
USE_INCLUDE_SUSv2(int silent;) /* Note: No longer relevant in SUSv3. */
|
||||
@@ -22,15 +22,17 @@ int tty_main(int argc, char **argv)
|
||||
xfunc_error_retval = 2; /* SUSv3 requires > 1 for error. */
|
||||
|
||||
USE_INCLUDE_SUSv2(silent = getopt32(argv, "s");)
|
||||
USE_INCLUDE_SUSv2(argc -= optind;)
|
||||
SKIP_INCLUDE_SUSv2(argc -= 1;)
|
||||
|
||||
/* gnu tty outputs a warning that it is ignoring all args. */
|
||||
bb_warn_ignoring_args(argc - optind);
|
||||
bb_warn_ignoring_args(argc);
|
||||
|
||||
retval = 0;
|
||||
|
||||
s = ttyname(0);
|
||||
if (s == NULL) {
|
||||
/* According to SUSv3, ttyname can on fail with EBADF or ENOTTY.
|
||||
/* According to SUSv3, ttyname can fail with EBADF or ENOTTY.
|
||||
* We know the file descriptor is good, so failure means not a tty. */
|
||||
s = "not a tty";
|
||||
retval = 1;
|
||||
|
||||
Loaded 100 of 513 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user