source: branches/stable/mindi-busybox/coreutils/cut.c @ 1770

Last change on this file since 1770 was 1770, checked in by Bruno Cornec, 13 years ago
  • Better output for mindi-busybox revision
  • Remove dummy file created on NFS - report from Arnaud Tiger <arnaud.tiger_at_hp.com>
  • strace useful for debug
  • fix new versions for pb (2.0.0 for mindi and 1.7.2 for mindi-busybox)
  • fix build process for mindi-busybox + options used in that version (dd for label-partitions-as-necessary)
  • fix typo in label-partitions-as-necessary which doesn't seem to work
  • Update to busybox 1.7.2
  • perl is now required at restore time to support uuid swap partitions (and will be used for many other thigs

in the future for sure)

  • next mindi version will be 2.0.0 due to all the changes made in it (udev may break working distros)
  • small optimization in mindi on keyboard handling (one single find instead of multiple)
  • better interaction for USB device when launching mindi manually
  • attempt to automatically guess block disk size for ramdisk
  • fix typos in bkphw
  • Fix the remaining problem with UUID support for swap partitions
  • Updates mondoarchive man page for USB support
  • Adds preliminary Hardware support to mindi (Proliant SSSTK)
  • Tries to add udev support also for rhel4
  • Fix UUID support which was still broken.
  • Be conservative in test for the start-nfs script
  • Update config file for mindi-busybox for 1.7.2 migration
  • Try to run around a busybox bug (1.2.2 pb on inexistant links)
  • Add build content for mindi-busybox in pb
  • Remove distributions content for mindi-busybox
  • Fix a warning on inexistant raidtab
  • Solve problem on tmpfs in restore init (Problem of inexistant symlink and busybox)
  • Create MONDO_CACHE and use it everywhere + creation at start
  • Really never try to eject a USB device
  • Fix a issue with &> usage (replaced with 1> and 2>)
  • Adds magic file to depllist in order to have file working + ldd which helps for debugging issues
  • tty modes correct to avoid sh error messages
  • Use ext3 normally and not ext2 instead
  • USB device should be corrected after reading (take 1st part)
  • Adds a mount_USB_here function derived from mount_CDROM_here
  • usb detection place before /dev detection in device name at restore time
  • Fix when restoring from USB: media is asked in interactive mode
  • Adds USB support for mondorestore
  • mount_cdrom => mount_media
  • elilo.efi is now searched throughout /boot/efi and not in a fixed place as there is no standard
  • untar-and-softlink => untar (+ interface change)
  • suppress useless softlinks creation/removal in boot process
  • avoids udevd messages on groups
  • Increase # of disks to 99 as in mindi at restore time (should be a conf file parameter)
  • skip existing big file creation
  • seems to work correctly for USB mindi boot
  • Adds group and tty link to udev conf
  • Always load usb-torage (even 2.6) to initiate USB bus discovery
  • Better printing of messages
  • Attempt to fix a bug in supporting OpenSusE 10.3 kernel for initramfs (mindi may now use multiple regex for kernel initrd detection)
  • Links were not correctly done as non relative for modules in mindi
  • exclusion of modules denied now works
  • Also create modules in their ordinary place, so that classical modprobe works + copy modules.dep
  • Fix bugs for DENY_MODS handling
  • Add device /dev/console for udev
  • ide-generic should now really be excluded
  • Fix a bug in major number for tty
  • If udev then adds modprobe/insmod to rootfs
  • tty0 is also cretaed with udev
  • ide-generic put rather in DENY_MODS
  • udevd remove from deplist s handled in mindi directly
  • better default for mindi when using --usb
  • Handles dynamically linked busybox (in case we want to use it soon ;-)
  • Adds fixed devices to create for udev
  • ide-generic should not be part of the initrd when using libata v2
  • support a dynamically linked udev (case on Ubuntu 7.10 and Mandriva 2008.0 so should be quite generic) This will give incitation to move to dyn. linked binaries in the initrd which will help for other tasks (ia6 4)
  • Improvement in udev support (do not use cl options not available in busybox)
  • Udev in mindi
    • auto creation of the right links at boot time with udev-links.conf(from Mandriva 2008.0)
    • rework startup of udev as current makes kernel crash (from Mandriva 2008.0)
    • add support for 64 bits udev
  • Try to render MyInsmod? silent at boot time
  • Adds udev support (mandatory for newest distributions to avoid remapping of devices in a different way as on the original system)
  • We also need vaft format support for USB boot
  • Adds libusual support (Ubuntu 7.10 needs it for USB)
  • Improve Ubuntu/Debian? keyboard detection and support
  • pbinit adapted to new pb (0.8.10). Filtering of docs done in it
  • Suppress some mondo warnings and errors on USB again
  • Tries to fix lack of files in deb mindi package
  • Verify should now work for USB devices
  • More log/mesages improvement for USB support
  • - Supress g_erase_tmpdir_and_scratchdir
  • Improve some log messages for USB support
  • Try to improve install in mindi to avoid issues with isolinux.cfg not installed vene if in the pkg :-(
  • Improve mindi-busybox build
  • In conformity with pb 0.8.9
  • Add support for Ubuntu 7.10 in build process
  • Add USB Key button to Menu UI (CD streamer removed)
  • Attempt to fix error messages on tmp/scratch files at the end by removing those dir at the latest possible.
  • Fix a bug linked to the size of the -E param which could be used (Arnaud Tiger/René? Ribaud).
  • Integrate ~/.pbrc content into mondorescue.pb (required project-builder >= 0.8.7)
  • Put mondorescue in conformity with new pb filtering rules
  • Add USB support at restore time (no test done yet). New start-usb script PB varibale added where useful
  • Unmounting USB device before removal of temporary scratchdir
  • Stil refining USB copy back to mondo (one command was not executed)
  • No need to have the image subdor in the csratchdir when USB.
  • umount the USB partition before attempting to use it
  • Remove useless copy from mindi to mondo at end of USB handling

(risky merge, we are raising the limits of 2 diverging branches. The status of stable is not completely sure as such. Will need lots of tests, but it's not yet done :-()
(merge -r1692:1769 $SVN_M/branches/2.2.5)

File size: 7.8 KB
Line 
1/* vi: set sw=4 ts=4: */
2/*
3 * cut.c - minimalist version of cut
4 *
5 * Copyright (C) 1999,2000,2001 by Lineo, inc.
6 * Written by Mark Whitley <markw@codepoet.org>
7 * debloated by Bernhard Fischer
8 *
9 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
10 */
11
12#include "libbb.h"
13
14/* This is a NOEXEC applet. Be very careful! */
15
16
17/* option vars */
18static const char optstring[] ALIGN1 = "b:c:f:d:sn";
19#define CUT_OPT_BYTE_FLGS   (1<<0)
20#define CUT_OPT_CHAR_FLGS   (1<<1)
21#define CUT_OPT_FIELDS_FLGS (1<<2)
22#define CUT_OPT_DELIM_FLGS  (1<<3)
23#define CUT_OPT_SUPPRESS_FLGS (1<<4)
24
25static char delim = '\t';   /* delimiter, default is tab */
26
27struct cut_list {
28    int startpos;
29    int endpos;
30};
31
32enum {
33    BOL = 0,
34    EOL = INT_MAX,
35    NON_RANGE = -1
36};
37
38/* growable array holding a series of lists */
39static struct cut_list *cut_lists;
40static unsigned int nlists; /* number of elements in above list */
41
42
43static int cmpfunc(const void *a, const void *b)
44{
45    return (((struct cut_list *) a)->startpos -
46            ((struct cut_list *) b)->startpos);
47
48}
49
50static void cut_file(FILE * file)
51{
52    char *line = NULL;
53    unsigned int linenum = 0;   /* keep these zero-based to be consistent */
54
55    /* go through every line in the file */
56    while ((line = xmalloc_getline(file)) != NULL) {
57
58        /* set up a list so we can keep track of what's been printed */
59        char * printed = xzalloc(strlen(line) * sizeof(char));
60        char * orig_line = line;
61        unsigned int cl_pos = 0;
62        int spos;
63
64        /* cut based on chars/bytes XXX: only works when sizeof(char) == byte */
65        if (option_mask32 & (CUT_OPT_CHAR_FLGS | CUT_OPT_BYTE_FLGS)) {
66            /* print the chars specified in each cut list */
67            for (; cl_pos < nlists; cl_pos++) {
68                spos = cut_lists[cl_pos].startpos;
69                while (spos < strlen(line)) {
70                    if (!printed[spos]) {
71                        printed[spos] = 'X';
72                        putchar(line[spos]);
73                    }
74                    spos++;
75                    if (spos > cut_lists[cl_pos].endpos
76                        || cut_lists[cl_pos].endpos == NON_RANGE)
77                        break;
78                }
79            }
80        } else if (delim == '\n') { /* cut by lines */
81            spos = cut_lists[cl_pos].startpos;
82
83            /* get out if we have no more lists to process or if the lines
84             * are lower than what we're interested in */
85            if (linenum < spos || cl_pos >= nlists)
86                goto next_line;
87
88            /* if the line we're looking for is lower than the one we were
89             * passed, it means we displayed it already, so move on */
90            while (spos < linenum) {
91                spos++;
92                /* go to the next list if we're at the end of this one */
93                if (spos > cut_lists[cl_pos].endpos
94                    || cut_lists[cl_pos].endpos == NON_RANGE) {
95                    cl_pos++;
96                    /* get out if there's no more lists to process */
97                    if (cl_pos >= nlists)
98                        goto next_line;
99                    spos = cut_lists[cl_pos].startpos;
100                    /* get out if the current line is lower than the one
101                     * we just became interested in */
102                    if (linenum < spos)
103                        goto next_line;
104                }
105            }
106
107            /* If we made it here, it means we've found the line we're
108             * looking for, so print it */
109            puts(line);
110            goto next_line;
111        } else {        /* cut by fields */
112            int ndelim = -1;    /* zero-based / one-based problem */
113            int nfields_printed = 0;
114            char *field = NULL;
115            const char delimiter[2] = { delim, 0 };
116
117            /* does this line contain any delimiters? */
118            if (strchr(line, delim) == NULL) {
119                if (!(option_mask32 & CUT_OPT_SUPPRESS_FLGS))
120                    puts(line);
121                goto next_line;
122            }
123
124            /* process each list on this line, for as long as we've got
125             * a line to process */
126            for (; cl_pos < nlists && line; cl_pos++) {
127                spos = cut_lists[cl_pos].startpos;
128                do {
129                    /* find the field we're looking for */
130                    while (line && ndelim < spos) {
131                        field = strsep(&line, delimiter);
132                        ndelim++;
133                    }
134
135                    /* we found it, and it hasn't been printed yet */
136                    if (field && ndelim == spos && !printed[ndelim]) {
137                        /* if this isn't our first time through, we need to
138                         * print the delimiter after the last field that was
139                         * printed */
140                        if (nfields_printed > 0)
141                            putchar(delim);
142                        fputs(field, stdout);
143                        printed[ndelim] = 'X';
144                        nfields_printed++;  /* shouldn't overflow.. */
145                    }
146
147                    spos++;
148
149                    /* keep going as long as we have a line to work with,
150                     * this is a list, and we're not at the end of that
151                     * list */
152                } while (spos <= cut_lists[cl_pos].endpos && line
153                         && cut_lists[cl_pos].endpos != NON_RANGE);
154            }
155        }
156        /* if we printed anything at all, we need to finish it with a
157         * newline cuz we were handed a chomped line */
158        putchar('\n');
159 next_line:
160        linenum++;
161        free(printed);
162        free(orig_line);
163    }
164}
165
166static const char _op_on_field[] ALIGN1 = " only when operating on fields";
167
168int cut_main(int argc, char **argv);
169int cut_main(int argc, char **argv)
170{
171    char *sopt, *ltok;
172
173    opt_complementary = "b--bcf:c--bcf:f--bcf";
174    getopt32(argv, optstring, &sopt, &sopt, &sopt, &ltok);
175//  argc -= optind;
176    argv += optind;
177    if (!(option_mask32 & (CUT_OPT_BYTE_FLGS | CUT_OPT_CHAR_FLGS | CUT_OPT_FIELDS_FLGS)))
178        bb_error_msg_and_die("expected a list of bytes, characters, or fields");
179
180    if (option_mask32 & CUT_OPT_DELIM_FLGS) {
181        if (strlen(ltok) > 1) {
182            bb_error_msg_and_die("the delimiter must be a single character");
183        }
184        delim = ltok[0];
185    }
186
187    /*  non-field (char or byte) cutting has some special handling */
188    if (!(option_mask32 & CUT_OPT_FIELDS_FLGS)) {
189        if (option_mask32 & CUT_OPT_SUPPRESS_FLGS) {
190            bb_error_msg_and_die
191                ("suppressing non-delimited lines makes sense%s",
192                 _op_on_field);
193        }
194        if (delim != '\t') {
195            bb_error_msg_and_die
196                ("a delimiter may be specified%s", _op_on_field);
197        }
198    }
199
200    /*
201     * parse list and put values into startpos and endpos.
202     * valid list formats: N, N-, N-M, -M
203     * more than one list can be separated by commas
204     */
205    {
206        char *ntok;
207        int s = 0, e = 0;
208
209        /* take apart the lists, one by one (they are separated with commas */
210        while ((ltok = strsep(&sopt, ",")) != NULL) {
211
212            /* it's actually legal to pass an empty list */
213            if (strlen(ltok) == 0)
214                continue;
215
216            /* get the start pos */
217            ntok = strsep(&ltok, "-");
218            if (ntok == NULL) {
219                bb_error_msg
220                    ("internal error: ntok is null for start pos!?\n");
221            } else if (strlen(ntok) == 0) {
222                s = BOL;
223            } else {
224                s = xatoi_u(ntok);
225                /* account for the fact that arrays are zero based, while
226                 * the user expects the first char on the line to be char #1 */
227                if (s != 0)
228                    s--;
229            }
230
231            /* get the end pos */
232            ntok = strsep(&ltok, "-");
233            if (ntok == NULL) {
234                e = NON_RANGE;
235            } else if (strlen(ntok) == 0) {
236                e = EOL;
237            } else {
238                e = xatoi_u(ntok);
239                /* if the user specified and end position of 0, that means "til the
240                 * end of the line */
241                if (e == 0)
242                    e = EOL;
243                e--;    /* again, arrays are zero based, lines are 1 based */
244                if (e == s)
245                    e = NON_RANGE;
246            }
247
248            /* if there's something left to tokenize, the user passed
249             * an invalid list */
250            if (ltok)
251                bb_error_msg_and_die("invalid byte or field list");
252
253            /* add the new list */
254            cut_lists = xrealloc(cut_lists, sizeof(struct cut_list) * (++nlists));
255            cut_lists[nlists-1].startpos = s;
256            cut_lists[nlists-1].endpos = e;
257        }
258
259        /* make sure we got some cut positions out of all that */
260        if (nlists == 0)
261            bb_error_msg_and_die("missing list of positions");
262
263        /* now that the lists are parsed, we need to sort them to make life
264         * easier on us when it comes time to print the chars / fields / lines
265         */
266        qsort(cut_lists, nlists, sizeof(struct cut_list), cmpfunc);
267    }
268
269    /* argv[0..argc-1] should be names of file to process. If no
270     * files were specified or '-' was specified, take input from stdin.
271     * Otherwise, we process all the files specified. */
272    if (argv[0] == NULL || LONE_DASH(argv[0])) {
273        cut_file(stdin);
274    } else {
275        FILE *file;
276
277        do {
278            file = fopen_or_warn(argv[0], "r");
279            if (file) {
280                cut_file(file);
281                fclose(file);
282            }
283        } while (*++argv);
284    }
285    if (ENABLE_FEATURE_CLEAN_UP)
286        free(cut_lists);
287    return EXIT_SUCCESS;
288}
Note: See TracBrowser for help on using the repository browser.