diff options
| -rw-r--r-- | Changelog | 76 | ||||
| -rw-r--r-- | busybox.def.h | 5 | ||||
| -rw-r--r-- | find.c | 23 | ||||
| -rw-r--r-- | findutils/find.c | 23 | ||||
| -rw-r--r-- | findutils/grep.c | 46 | ||||
| -rw-r--r-- | grep.c | 46 | ||||
| -rw-r--r-- | internal.h | 6 | ||||
| -rw-r--r-- | regexp.c | 826 | ||||
| -rw-r--r-- | smtpout | 2 | ||||
| -rw-r--r-- | utility.c | 151 |
10 files changed, 1006 insertions, 198 deletions
@@ -1,7 +1,81 @@ +0.31 + * I added a changelog for version 0.30. + * adjusted find internals to make it smaller, and removed + some redundancy. + * Fixed a segfault in ps when /etc/passwd or /etc/group + are absent. Now will warn you and carry on. + * Added in optional _real_ regular expression support (to be + the basis for a future sed utility). When compiled in, + adds 3.9k. + + 0.30 Major changes -- lots of stuff rewritten. Many thanks to Lineo for paying me to make these updates. If you have any problems with busybox, - or notice any bugs -- please let me know so I can fix it. + or notice any bugs -- please let me know so I can fix it. These + changes include: + + Core Changes: + * busybox can now invoke apps in two ways: via symlinks to the + busybox binary, and as 'busybox [function] [arguments]...' + * When invoked as busybox, the list of currently compiled in + functions is printed out (no this is not bloat -- the list + has to be there anyway to map invocation name to function). + * busybox no longer parses command lines for apps or displays their + usage info. Each app gets to handle (or not handle) this for + itself. + * Eliminated monadic, dyadic, descend, block_device, and + postprocess. It was cumbersome to have so many programs + cobbled together in this way. Without them, the app is much + more granular. + * All shared code now lives in utility.c, and is properly + ifdef'ed to be only included for those apps requiring it. + * Eliminated struct FileInfo (the basis of monadic, dyadic, etc) + so now each app has the function prototype of (da-dum): + extern int foo_main(int argc, char** argv); + which speeds integration of new apps. + * Adjusted the Makefile to make it easier to + {en|dis}able debugging. + * Changed default compiler optimization to -Os + (optimize for smaller binaries). + + App Changes: + * To cope with the new app function prototype and the removal of + monadic, dyadic, etc, the following apps were re-written: + * cat - Works same as always. + * chgrp, chmod, chown - rewrite. Combined into a single + source file. Absorbed patches from Enrique Zanardi <ezanard@debian.org> + that removes the dependency on libc6 libnss* libraries. + * cp - Can now do 'cp -a' can can copy devices, + pipes, symlinks, as well as recursive or non-recursive dir copies. + * fdflush - adjusted to remove dependancy on struct FileInfo. + * find - Now includes some basic regexp matching + which will be the basic of a future mini-sed. + * ln - Same functionality. + * mkdir - Added -p flag to feature set. + * mv - rewrite. + * rm - Added -f flag to feature set. + * rmdir - Same functionality. + * swapon, swapoff - Combined into a single binary. No longer + uses /etc/swaps. swap{on|off} -a uses /etc/fstab instead. + * touch - Same functionality. + * date - adjusted with a patch from Matthew Grant <grantma@anathoth.gen.nz> + to accomodate glibc timezone support. I then ripped out GNU getopt. + * mkswap -- new version merged from util-linux. Can now make >128Meg swaps. + * Replaced the old and star, unstar, and tarcat with the tar + implementation from sash. Now tar behaves as god intended + it to (i.e. tar -xvf <file> and tar -cf <file> <dir> work). + * dd -- rewritten. Can with with files, stdin, stdout. + * Added the following new apps: + * loadfont -- added from debian boot floppies + * chroot -- added based on a patch from Paolo Molaro <lupus@lettere.unipd.it> + * grep -- I just wrote it. Only matches simple strings + * ps -- I just wrote it. Has _no_ options at all, but works. + * fsck_minix, mkfs_minix -- added from util-linux, but I ripped out + internationalization and such to make them smaller. + * sfdisk -- Added from util-linux (minus internationalization and such). + * Probably some other changes that I forgot to document... + -Erik Andersen 0.28 diff --git a/busybox.def.h b/busybox.def.h index 692f24e..033ccca 100644 --- a/busybox.def.h +++ b/busybox.def.h @@ -40,6 +40,7 @@ //#define BB_PRINTF #define BB_PS #define BB_PWD +#define BB_REGEXP #define BB_REBOOT #define BB_RM #define BB_RMDIR @@ -52,6 +53,8 @@ //#define BB_TRUE_FALSE // Supplied by ash #define BB_UMOUNT #define BB_UPDATE -#define BB_UTILITY #define BB_ZCAT //#define BB_GZIP +// Don't turn BB_UTILITY off. It contains support code +// that compiles to 0 if everything else if turned off. +#define BB_UTILITY @@ -21,14 +21,15 @@ * */ +#include "internal.h" +#include "regexp.h" #include <stdio.h> #include <unistd.h> #include <dirent.h> -#include "internal.h" static char* pattern=NULL; -static char* directory=NULL; +static char* directory="."; static int dereferenceFlag=FALSE; static const char find_usage[] = "find [path...] [expression]\n" @@ -41,7 +42,7 @@ static int fileAction(const char *fileName, struct stat* statbuf) { if (pattern==NULL) fprintf(stdout, "%s\n", fileName); - else if (match(fileName, pattern) == TRUE) + else if (find_match(fileName, pattern, TRUE) == TRUE) fprintf(stdout, "%s\n", fileName); return( TRUE); } @@ -53,7 +54,7 @@ static int dirAction(const char *fileName, struct stat* statbuf) if (pattern==NULL) fprintf(stdout, "%s\n", fileName); - else if (match(fileName, pattern) == TRUE) + else if (find_match(fileName, pattern, TRUE) == TRUE) fprintf(stdout, "%s\n", fileName); dir = opendir( fileName); @@ -71,22 +72,18 @@ static int dirAction(const char *fileName, struct stat* statbuf) int find_main(int argc, char **argv) { - if (argc <= 1) { - dirAction( ".", NULL); - } - /* peel off the "find" */ argc--; argv++; - if (**argv != '-') { + if ( argc > 0 && **argv != '-') { directory=*argv; argc--; argv++; } /* Parse any options */ - while (**argv == '-') { + while (argc > 0 && **argv == '-') { int stopit=FALSE; while (*++(*argv) && stopit==FALSE) switch (**argv) { case 'f': @@ -120,6 +117,10 @@ int find_main(int argc, char **argv) break; } - dirAction( directory, NULL); + if (recursiveAction(directory, TRUE, FALSE, FALSE, + fileAction, fileAction) == FALSE) { + exit( FALSE); + } + exit(TRUE); } diff --git a/findutils/find.c b/findutils/find.c index 1db3322..c154cf4 100644 --- a/findutils/find.c +++ b/findutils/find.c @@ -21,14 +21,15 @@ * */ +#include "internal.h" +#include "regexp.h" #include <stdio.h> #include <unistd.h> #include <dirent.h> -#include "internal.h" static char* pattern=NULL; -static char* directory=NULL; +static char* directory="."; static int dereferenceFlag=FALSE; static const char find_usage[] = "find [path...] [expression]\n" @@ -41,7 +42,7 @@ static int fileAction(const char *fileName, struct stat* statbuf) { if (pattern==NULL) fprintf(stdout, "%s\n", fileName); - else if (match(fileName, pattern) == TRUE) + else if (find_match(fileName, pattern, TRUE) == TRUE) fprintf(stdout, "%s\n", fileName); return( TRUE); } @@ -53,7 +54,7 @@ static int dirAction(const char *fileName, struct stat* statbuf) if (pattern==NULL) fprintf(stdout, "%s\n", fileName); - else if (match(fileName, pattern) == TRUE) + else if (find_match(fileName, pattern, TRUE) == TRUE) fprintf(stdout, "%s\n", fileName); dir = opendir( fileName); @@ -71,22 +72,18 @@ static int dirAction(const char *fileName, struct stat* statbuf) int find_main(int argc, char **argv) { - if (argc <= 1) { - dirAction( ".", NULL); - } - /* peel off the "find" */ argc--; argv++; - if (**argv != '-') { + if ( argc > 0 && **argv != '-') { directory=*argv; argc--; argv++; } /* Parse any options */ - while (**argv == '-') { + while (argc > 0 && **argv == '-') { int stopit=FALSE; while (*++(*argv) && stopit==FALSE) switch (**argv) { case 'f': @@ -120,6 +117,10 @@ int find_main(int argc, char **argv) break; } - dirAction( directory, NULL); + if (recursiveAction(directory, TRUE, FALSE, FALSE, + fileAction, fileAction) == FALSE) { + exit( FALSE); + } + exit(TRUE); } diff --git a/findutils/grep.c b/findutils/grep.c index a495c62..44ca028 100644 --- a/findutils/grep.c +++ b/findutils/grep.c @@ -22,6 +22,7 @@ */ #include "internal.h" +#include "regexp.h" #include <stdio.h> #include <dirent.h> #include <errno.h> @@ -30,44 +31,17 @@ #include <time.h> #include <ctype.h> - static const char grep_usage[] = "grep [-ihn]... PATTERN [FILE]...\n" "Search for PATTERN in each FILE or standard input.\n\n" "\t-h\tsuppress the prefixing filename on output\n" "\t-i\tignore case distinctions\n" "\t-n\tprint line number with output lines\n\n" +#if defined BB_REGEXP +"This version of grep matches full regexps.\n"; +#else "This version of grep matches strings (not full regexps).\n"; - - -/* - * See if the specified needle is found in the specified haystack. - */ -static int search (const char *haystack, const char *needle, int ignoreCase) -{ - - if (ignoreCase == FALSE) { - haystack = strstr (haystack, needle); - if (haystack == NULL) - return FALSE; - return TRUE; - } else { - int i; - char needle1[BUF_SIZE]; - char haystack1[BUF_SIZE]; - - strncpy( haystack1, haystack, sizeof(haystack1)); - strncpy( needle1, needle, sizeof(needle1)); - for( i=0; i<sizeof(haystack1) && haystack1[i]; i++) - haystack1[i]=tolower( haystack1[i]); - for( i=0; i<sizeof(needle1) && needle1[i]; i++) - needle1[i]=tolower( needle1[i]); - haystack = strstr (haystack1, needle1); - if (haystack == NULL) - return FALSE; - return TRUE; - } -} +#endif extern int grep_main (int argc, char **argv) @@ -80,7 +54,7 @@ extern int grep_main (int argc, char **argv) int ignoreCase=FALSE; int tellLine=FALSE; long line; - char buf[BUF_SIZE]; + char haystack[BUF_SIZE]; ignoreCase = FALSE; tellLine = FALSE; @@ -128,21 +102,21 @@ extern int grep_main (int argc, char **argv) line = 0; - while (fgets (buf, sizeof (buf), fp)) { + while (fgets (haystack, sizeof (haystack), fp)) { line++; - cp = &buf[strlen (buf) - 1]; + cp = &haystack[strlen (haystack) - 1]; if (*cp != '\n') fprintf (stderr, "%s: Line too long\n", name); - if (search (buf, needle, ignoreCase)==TRUE) { + if (find_match(haystack, needle, ignoreCase) == TRUE) { if (tellName==TRUE) printf ("%s: ", name); if (tellLine==TRUE) printf ("%ld: ", line); - fputs (buf, stdout); + fputs (haystack, stdout); } } @@ -22,6 +22,7 @@ */ #include "internal.h" +#include "regexp.h" #include <stdio.h> #include <dirent.h> #include <errno.h> @@ -30,44 +31,17 @@ #include <time.h> #include <ctype.h> - static const char grep_usage[] = "grep [-ihn]... PATTERN [FILE]...\n" "Search for PATTERN in each FILE or standard input.\n\n" "\t-h\tsuppress the prefixing filename on output\n" "\t-i\tignore case distinctions\n" "\t-n\tprint line number with output lines\n\n" +#if defined BB_REGEXP +"This version of grep matches full regexps.\n"; +#else "This version of grep matches strings (not full regexps).\n"; - - -/* - * See if the specified needle is found in the specified haystack. - */ -static int search (const char *haystack, const char *needle, int ignoreCase) -{ - - if (ignoreCase == FALSE) { - haystack = strstr (haystack, needle); - if (haystack == NULL) - return FALSE; - return TRUE; - } else { - int i; - char needle1[BUF_SIZE]; - char haystack1[BUF_SIZE]; - - strncpy( haystack1, haystack, sizeof(haystack1)); - strncpy( needle1, needle, sizeof(needle1)); - for( i=0; i<sizeof(haystack1) && haystack1[i]; i++) - haystack1[i]=tolower( haystack1[i]); - for( i=0; i<sizeof(needle1) && needle1[i]; i++) - needle1[i]=tolower( needle1[i]); - haystack = strstr (haystack1, needle1); - if (haystack == NULL) - return FALSE; - return TRUE; - } -} +#endif extern int grep_main (int argc, char **argv) @@ -80,7 +54,7 @@ extern int grep_main (int argc, char **argv) int ignoreCase=FALSE; int tellLine=FALSE; long line; - char buf[BUF_SIZE]; + char haystack[BUF_SIZE]; ignoreCase = FALSE; tellLine = FALSE; @@ -128,21 +102,21 @@ extern int grep_main (int argc, char **argv) line = 0; - while (fgets (buf, sizeof (buf), fp)) { + while (fgets (haystack, sizeof (haystack), fp)) { line++; - cp = &buf[strlen (buf) - 1]; + cp = &haystack[strlen (haystack) - 1]; if (*cp != '\n') fprintf (stderr, "%s: Line too long\n", name); - if (search (buf, needle, ignoreCase)==TRUE) { + if (find_match(haystack, needle, ignoreCase) == TRUE) { if (tellName==TRUE) printf ("%s: ", name); if (tellLine==TRUE) printf ("%ld: ", line); - fputs (buf, stdout); + fputs (haystack, stdout); } } @@ -130,7 +130,6 @@ int fullRead(int fd, char *buf, int len); int recursiveAction(const char *fileName, int recurse, int followLinks, int delayDirAction, int (*fileAction) (const char *fileName, struct stat* statbuf), int (*dirAction) (const char *fileName, struct stat* statbuf)); -int match(const char* text, const char * pattern); const char* timeString(time_t timeVal); extern void createPath (const char *name, int mode); @@ -166,8 +165,9 @@ static inline int clrbit(char * addr,unsigned int nr) return __res != 0; } -#endif +#endif /* inline bitops junk */ -#endif + +#endif /* _INTERNAL_H_ */ diff --git a/regexp.c b/regexp.c new file mode 100644 index 0000000..6017d79 --- /dev/null +++ b/regexp.c @@ -0,0 +1,826 @@ +/* regexp.c */ + +#include "internal.h" +#include "regexp.h" +#include <setjmp.h> +#include <stdio.h> +#include <ctype.h> + + +#if ( defined BB_GREP || defined BB_FIND ) + +/* This also tries to find a needle in a haystack, but uses + * real regular expressions.... The fake regular expression + * version of find_match lives in utility.c. Using this version + * will add 3.9k to busybox... + * -Erik Andersen + */ +extern int find_match(char *haystack, char *needle, int ignoreCase) +{ + int status; + struct regexp* re; + re = regcomp( needle); + status = regexec(re, haystack, FALSE, ignoreCase); + free( re); + return( status); +} + + +/* code swiped from elvis-tiny 1.4 (a clone of vi) and adjusted to + * suit the needs of busybox by Erik Andersen. + * + * From the README: + * "Elvis is freely redistributable, in either source form or executable form. + * There are no restrictions on how you may use it". + * Elvis was written by Steve Kirkendall <kirkenda@cs.pdx.edu> + * + * + * This file contains the code that compiles regular expressions and executes + * them. It supports the same syntax and features as vi's regular expression + * code. Specifically, the meta characters are: + * ^ matches the beginning of a line + * $ matches the end of a line + * \< matches the beginning of a word + * \> matches the end of a word + * . matches any single character + * [] matches any character in a character class + * \( delimits the start of a subexpression + * \) delimits the end of a subexpression + * * repeats the preceding 0 or more times + * NOTE: You cannot follow a \) with a *. + * + * The physical structure of a compiled RE is as follows: + * - First, there is a one-byte value that says how many character classes + * are used in this regular expression + * - Next, each character class is stored as a bitmap that is 256 bits + * (32 bytes) long. + * - A mixture of literal characters and compiled meta characters follows. + * This begins with M_BEGIN(0) and ends with M_END(0). All meta chars + * are stored as a \n followed by a one-byte code, so they take up two + * bytes apiece. Literal characters take up one byte apiece. \n can't + * be used as a literal character. + * + */ + + + +static char *previous; /* the previous regexp, used when null regexp is given */ +static char *previous1; /* a copy of the text from the previous substitution for regsub()*/ + + +/* These are used to classify or recognize meta-characters */ +#define META '\0' +#define BASE_META(m) ((m) - 256) +#define INT_META(c) ((c) + 256) +#define IS_META(m) ((m) >= 256) +#define IS_CLASS(m) ((m) >= M_CLASS(0) && (m) <= M_CLASS(9)) +#define IS_START(m) ((m) >= M_START(0) && (m) <= M_START(9)) +#define IS_END(m) ((m) >= M_END(0) && (m) <= M_END(9)) +#define IS_CLOSURE(m) ((m) >= M_SPLAT && (m) <= M_QMARK) +#define ADD_META(s,m) (*(s)++ = META, *(s)++ = BASE_META(m)) +#define GET_META(s) (*(s) == META ? INT_META(*++(s)) : *s) + +/* These are the internal codes used for each type of meta-character */ +#define M_BEGLINE 256 /* internal code for ^ */ +#define M_ENDLINE 257 /* internal code for $ */ +#define M_BEGWORD 258 /* internal code for \< */ +#define M_ENDWORD 259 /* internal code for \> */ +#define M_ANY 260 /* internal code for . */ +#define M_SPLAT 261 /* internal code for * */ +#define M_PLUS 262 /* internal code for \+ */ +#define M_QMARK 263 /* internal code for \? */ +#define M_CLASS(n) (264+(n)) /* internal code for [] */ +#define M_START(n) (274+(n)) /* internal code for \( */ +#define M_END(n) (284+(n)) /* internal code for \) */ + +/* These are used during compilation */ +static int class_cnt; /* used to assign class IDs */ +static int start_cnt; /* used to assign start IDs */ +static int end_stk[NSUBEXP];/* used to assign end IDs */ +static int end_sp; +static char *retext; /* points to the text being compiled */ + +/* error-handling stuff */ +jmp_buf errorhandler; +#define FAIL(why) fprintf(stderr, why); longjmp(errorhandler, 1) + + + + +/* This function builds a bitmap for a particular class */ +/* text -- start of the class */ +/* bmap -- the bitmap */ +static char *makeclass(char* text, char* bmap) +{ + int i; + int complement = 0; + + + /* zero the bitmap */ + for (i = 0; bmap && i < 32; i++) + { + bmap[i] = 0; + } + + /* see if we're going to complement this class */ + if (*text == '^') + { + text++; + complement = 1; + } + + /* add in the characters */ + while (*text && *text != ']') + { + /* is this a span of characters? */ + if (text[1] == '-' && text[2]) + { + /* spans can't be backwards */ + if (text[0] > text[2]) + { + FAIL("Backwards span in []"); + } + + /* add each character in the span to the bitmap */ + for (i = text[0]; bmap && i <= text[2]; i++) + { + bmap[i >> 3] |= (1 << (i & 7)); + } + + /* move past this span */ + text += 3; + } + else + { + /* add this single character to the span */ + i = *text++; + if (bmap) + { + bmap[i >> 3] |= (1 << (i & 7)); + } + } + } + + /* make sure the closing ] is missing */ + if (*text++ != ']') + { + FAIL("] missing"); + } + + /* if we're supposed to complement this class, then do so */ + if (complement && bmap) + { + for (i = 0; i < 32; i++) + { + bmap[i] = ~bmap[i]; + } + } + + return text; +} + + + + +/* This function gets the next character or meta character from a string. + * The pointer is incremented by 1, or by 2 for \-quoted characters. For [], + * a bitmap is generated via makeclass() (if re is given), and the + * character-class text is skipped. + */ +static int gettoken(sptr, re) + char **sptr; + regexp *re; +{ + int c; + + c = **sptr; + ++*sptr; + if (c == '\\') + { + c = **sptr; + ++*sptr; + switch (c) + { + case '<': + return M_BEGWORD; + + case '>': + return M_ENDWORD; + + case '(': + if (start_cnt >= NSUBEXP) + { + FAIL("Too many \\(s"); + } + end_stk[end_sp++] = start_cnt; + return M_START(start_cnt++); + + case ')': + if (end_sp <= 0) + { + FAIL("Mismatched \\)"); + } + return M_END(end_stk[--end_sp]); + + case '*': + return M_SPLAT; + + case '.': + return M_ANY; + + case '+': + return M_PLUS; + + case '?': + return M_QMARK; + + default: + return c; + } + } + else { + switch (c) + { + case '^': + if (*sptr == retext + 1) + { + return M_BEGLINE; + } + return c; + + case '$': + if (!**sptr) + { + return M_ENDLINE; + } + return c; + + case '.': + return M_ANY; + + case '*': + return M_SPLAT; + + case '[': + /* make sure we don't have too many classes */ + if (class_cnt >= 10) + { + FAIL("Too many []s"); + } + + /* process the character list for this class */ + if (re) + { + /* generate the bitmap for this class */ + *sptr = makeclass(*sptr, re->program + 1 + 32 * class_cnt); + } + else + { + /* skip to end of the class */ + *sptr = makeclass(*sptr, (char *)0); + } + return M_CLASS(class_cnt++); + + default: + return c; + } + } + /*NOTREACHED*/ +} + + + + +/* This function calculates the number of bytes that will be needed for a + * compiled RE. Its argument is the uncompiled version. It is not clever + * about catching syntax errors; that is done in a later pass. + */ +static unsigned calcsize(text) + char *text; +{ + unsigned size; + int token; + + retext = text; + class_cnt = 0; + start_cnt = 1; + end_sp = 0; + size = 5; + while ((token = gettoken(&text, (regexp *)0)) != 0) + { + if (IS_CLASS(token)) + { + size += 34; + } + else if (IS_META(token)) + { + size += 2; + } + else + { + size++; + } + } + + return size; +} + + + +/*---------------------------------------------------------------------------*/ + + +/* This function checks for a match between a character and a token which is + * known to represent a single character. It returns 0 if they match, or + * 1 if they don't. + */ +static int match1(regexp* re, char ch, int token, int ignoreCase) +{ + if (!ch) + { + /* the end of a line can't match any RE of width 1 */ + return 1; + } + if (token == M_ANY) + { + return 0; + } + else if (IS_CLASS(token)) + { + if (re->program[1 + 32 * (token - M_CLASS(0)) + (ch >> 3)] & (1 << (ch & 7))) + return 0; + } + else if (ch == token + || (ignoreCase==TRUE && isupper(ch) && tolower(ch) == token)) + { + return 0; + } + return 1; +} + + + +/* This function checks characters up to and including the next closure, at + * which point it does a recursive call to check the rest of it. This function + * returns 0 if everything matches, or 1 if something doesn't match. + */ +/* re -- the regular expression */ +/* str -- the string */ +/* prog -- a portion of re->program, an compiled RE */ +/* here -- a portion of str, the string to compare it to */ +static int match(regexp* re, char* str, char* prog, char* here, int ignoreCase) +{ + int token; + int nmatched; + int closure; + + for (token = GET_META(prog); !IS_CLOSURE(token); prog++, token = GET_META(prog)) + { + switch (token) + { + /*case M_BEGLINE: can't happen; re->bol is used instead */ + case M_ENDLINE: + if (*here) + return 1; + break; + + case M_BEGWORD: + if (here != str && + (here[-1] == '_' || + (isascii(here[-1]) && isalnum(here[-1])))) + return 1; + break; + + case M_ENDWORD: + if ((here[0] == '_' || isascii(here[0])) && isalnum(here[0])) + return 1; + break; + + case M_START(0): + case M_START(1): + case M_START(2): + case M_START(3): + case M_START(4): + case M_START(5): + case M_START(6): + case M_START(7): + case M_START(8): + case M_START(9): + re->startp[token - M_START(0)] = (char *)here; + break; + + case M_END(0): + case M_END(1): + case M_END(2): + case M_END(3): + case M_END(4): + case M_END(5): + case M_END(6): + case M_END(7): + case M_END(8): + case M_END(9): + re->endp[token - M_END(0)] = (char *)here; + if (token == M_END(0)) + { + return 0; + } + break; + + default: /* literal, M_CLASS(n), or M_ANY */ + if (match1(re, *here, token, ignoreCase) != 0) + return 1; + here++; + } + } + + /* C L O S U R E */ + + /* step 1: see what we have to match against, and move "prog" to point + * the the remainder of the compiled RE. + */ + closure = token; + prog++, token = GET_META(prog); + prog++; + + /* step 2: see how many times we can match that token against the string */ + for (nmatched = 0; + (closure != M_QMARK || nmatched < 1) && *here && match1(re, *here, token, ignoreCase) == 0; + nmatched++, here++) + { + } + + /* step 3: try to match the remainder, and back off if it doesn't */ + while (nmatched >= 0 && match(re, str, prog, here, ignoreCase) != 0) + { + nmatched--; + here--; + } + + /* so how did it work out? */ + if (nmatched >= ((closure == M_PLUS) ? 1 : 0)) + return 0; + return 1; +} + + +/* This function compiles a regexp. */ +extern regexp *regcomp(char* text) +{ + int needfirst; + unsigned size; + int token; + int peek; + char *build; + regexp *re; + + + /* prepare for error handling */ + re = (regexp *)0; + if (setjmp(errorhandler)) + { + if (re) + { + free(re); + } + return (regexp *)0; + } + + /* if an empty regexp string was given, use the previous one */ + if (*text == 0) + { + if (!previous) + { + FAIL("No previous RE"); + } + text = previous; + } + else /* non-empty regexp given, so remember it */ + { + if (previous) + free(previous); + previous = (char *)malloc((unsigned)(strlen(text) + 1)); + if (previous) + strcpy(previous, text); + } + + /* allocate memory */ + class_cnt = 0; + start_cnt = 1; + end_sp = 0; + retext = text; + size = calcsize(text) + sizeof(regexp); + re = (regexp *)malloc((unsigned)size); + + if (!re) + { + FAIL("Not enough memory for this RE"); + } + + /* compile it */ + build = &re->program[1 + 32 * class_cnt]; + re->program[0] = class_cnt; + for (token = 0; token < NSUBEXP; token++) + { + re->startp[token] = re->endp[token] = (char *)0; + } + re->first = 0; + re->bol = 0; + re->minlen = 0; + needfirst = 1; + class_cnt = 0; + start_cnt = 1; + end_sp = 0; + retext = text; + for (token = M_START(0), peek = gettoken(&text, re); + token; + token = peek, peek = gettoken(&text, re)) + { + /* special processing for the closure operator */ + if (IS_CLOSURE(peek)) + { + /* detect misuse of closure operator */ + if (IS_START(token)) + { + FAIL("* or \\+ or \\? follows nothing"); + } + else if (IS_META(token) && token != M_ANY && !IS_CLASS(token)) + { + FAIL("* or \\+ or \\? can only follow a normal character or . or []"); + } + + /* it is okay -- make it prefix instead of postfix */ + ADD_META(build, peek); + + /* take care of "needfirst" - is this the first char? */ + if (needfirst && peek == M_PLUS && !IS_META(token)) + { + re->first = token; + } + needfirst = 0; + + /* we used "peek" -- need to refill it */ + peek = gettoken(&text, re); + if (IS_CLOSURE(peek)) + { + FAIL("* or \\+ or \\? doubled up"); + } + } + else if (!IS_META(token)) + { + /* normal char is NOT argument of closure */ + if (needfirst) + { + re->first = token; + needfirst = 0; + } + re->minlen++; + } + else if (token == M_ANY || IS_CLASS(token)) + { + /* . or [] is NOT argument of closure */ + needfirst = 0; + re->minlen++; + } + + /* the "token" character is not closure -- process it normally */ + if (token == M_BEGLINE) + { + /* set the BOL flag instead of storing M_BEGLINE */ + re->bol = 1; + } + else if (IS_META(token)) + { + ADD_META(build, token); + } + else + { + *build++ = token; + } + } + + /* end it with a \) which MUST MATCH the opening \( */ + ADD_META(build, M_END(0)); + if (end_sp > 0) + { + FAIL("Not enough \\)s"); + } + + return re; +} + + + + +/* This function searches through a string for text that matches an RE. */ +/* re -- the compiled regexp to search for */ +/* str -- the string to search through */ +/* bol -- does str start at the beginning of a line? (boolean) */ +/* ignoreCase -- ignoreCase or not */ +extern int regexec(struct regexp* re, char* str, int bol, int ignoreCase) +{ + char *prog; /* the entry point of re->program */ + int len; /* length of the string */ + char *here; + + /* if must start at the beginning of a line, and this isn't, then fail */ + if (re->bol && bol==TRUE) + { + return FALSE; + } + + len = strlen(str); + prog = re->program + 1 + 32 * re->program[0]; + + /* search for the RE in the string */ + if (re->bol) + { + /* must occur at BOL */ + if ((re->first + && match1(re, *(char *)str, re->first, ignoreCase))/* wrong first letter? */ + || len < re->minlen /* not long enough? */ + || match(re, (char *)str, prog, str, ignoreCase)) /* doesn't match? */ + return FALSE; /* THEN FAIL! */ + } + else if (ignoreCase == FALSE) + { + /* can occur anywhere in the line, noignorecase */ + for (here = (char *)str; + (re->first && re->first != *here) + || match(re, (char *)str, prog, here, ignoreCase); + here++, len--) + { + if (len < re->minlen) + return FALSE; + } + } + else + { + /* can occur anywhere in the line, ignorecase */ + for (here = (char *)str; + (re->first && match1(re, *here, (int)re->first, ignoreCase)) + || match(re, (char *)str, prog, here, ignoreCase); + here++, len--) + { + if (len < re->minlen) + return FALSE; + } + } + + /* if we didn't fail, then we must have succeeded */ + return TRUE; +} + + + + + +/* This performs substitutions after a regexp match has been found. */ +extern void regsub(regexp* re, char* src, char* dst) +{ + char *cpy; + char *end; + char c; + char *start; + int mod; + + mod = 0; + + start = src; + while ((c = *src++) != '\0') + { + /* recognize any meta characters */ + if (c == '&') + { + cpy = re->startp[0]; + end = re->endp[0]; + } + else if (c == '~') + { + cpy = previous1; + if (cpy) + end = cpy + strlen(cpy); + } + else + if (c == '\\') + { + c = *src++; + switch (c) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + /* \0 thru \9 mean "copy subexpression" */ + c -= '0'; + cpy = re->startp[(int)c]; + end = re->endp[(int)c]; + break; + case 'U': + case 'u': + case 'L': + case 'l': + /* \U and \L mean "convert to upper/lowercase" */ + mod = c; + continue; + + case 'E': + case 'e': + /* \E ends the \U or \L */ + mod = 0; + continue; + case '&': + /* "\&" means "original text" */ + *dst++ = c; + continue; + + case '~': + /* "\~" means "previous text, if any" */ + *dst++ = c; + continue; + default: + /* ordinary char preceded by backslash */ + *dst++ = c; + continue; + } + } + else + { + /* ordinary character, so just copy it */ + *dst++ = c; + continue; + } + + /* Note: to reach this point in the code, we must have evaded + * all "continue" statements. To do that, we must have hit + * a metacharacter that involves copying. + */ + + /* if there is nothing to copy, loop */ + if (!cpy) + continue; + + /* copy over a portion of the original */ + while (cpy < end) + { + switch (mod) + { + case 'U': + case 'u': + /* convert to uppercase */ + if (isascii(*cpy) && islower(*cpy)) + { + *dst++ = toupper(*cpy); + cpy++; + } + else + { + *dst++ = *cpy++; + } + break; + + case 'L': + case 'l': + /* convert to lowercase */ + if (isascii(*cpy) && isupper(*cpy)) + { + *dst++ = tolower(*cpy); + cpy++; + } + else + { + *dst++ = *cpy++; + } + break; + + default: + /* copy without any conversion */ + *dst++ = *cpy++; + } + + /* \u and \l end automatically after the first char */ + if (mod && (mod == 'u' || mod == 'l')) + { + mod = 0; + } + } + } + *dst = '\0'; + + /* remember what text we inserted this time */ + if (previous1) + free(previous1); + previous1 = (char *)malloc((unsigned)(strlen(start) + 1)); + if (previous1) + strcpy(previous1, start); +} + + +#endif /* BB_REGEXP */ + + diff --git a/smtpout b/smtpout deleted file mode 100644 index 635a83c..0000000 --- a/smtpout +++ /dev/null @@ -1,2 +0,0 @@ -echo '.' >smtpout
echo 'QUIT' >smtpout -kjfjkjd @@ -53,12 +53,17 @@ volatile void usage(const char *usage) int get_kernel_revision() { - FILE *f; + FILE *file; int major=0, minor=0, patch=0; - - f = fopen("/proc/sys/kernel/osrelease","r"); - fscanf(f,"%d.%d.%d",&major,&minor,&patch); - fclose(f); + char* filename="/proc/sys/kernel/osrelease"; + + file = fopen(filename,"r"); + if (file == NULL) { + perror(filename); + return( 0); + } + fscanf(file,"%d.%d.%d",&major,&minor,&patch); + fclose(file); return major*65536 + minor*256 + patch; } @@ -312,94 +317,6 @@ const char *timeString(time_t timeVal) /* - * Routine to see if a text string is matched by a wildcard pattern. - * Returns TRUE if the text is matched, or FALSE if it is not matched - * or if the pattern is invalid. - * * matches zero or more characters - * ? matches a single character - * [abc] matches 'a', 'b' or 'c' - * \c quotes character c - * Adapted from code written by Ingo Wilken. - */ -int match(const char *text, const char *pattern) -{ - const char *retryPat; - const char *retryText; - int ch; - int found; - - retryPat = NULL; - retryText = NULL; - - while (*text || *pattern) { - ch = *pattern++; - - switch (ch) { - case '*': - retryPat = pattern; - retryText = text; - break; - - case '[': - found = FALSE; - - while ((ch = *pattern++) != ']') { - if (ch == '\\') - ch = *pattern++; - - if (ch == '\0') - return FALSE; - - if (*text == ch) - found = TRUE; - } - - if (!found) { - pattern = retryPat; - text = ++retryText; - } - - /* fall into next case */ - - case '?': - if (*text++ == '\0') - return FALSE; - - break; - - case '\\': - ch = *pattern++; - - if (ch == '\0') - return FALSE; - - /* fall into next case */ - - default: - if (*text == ch) { - if (*text) - text++; - break; - } - - if (*text) { - pattern = retryPat; - text = ++retryText; - break; - } - - return FALSE; - } - - if (pattern == NULL) - return FALSE; - } - - return TRUE; -} - - -/* * Write all of the supplied buffer out to a file. * This does multiple writes as necessary. * Returns the amount written, or -1 on an error. @@ -695,13 +612,17 @@ parse_mode( const char* s, mode_t* theMode) uid_t my_getid(const char *filename, char *name, uid_t id) { - FILE *stream; + FILE *file; char *rname, *start, *end, buf[128]; uid_t rid; - stream=fopen(filename,"r"); + file=fopen(filename,"r"); + if (file == NULL) { + perror(filename); + return (-1); + } - while (fgets (buf, 128, stream) != NULL) { + while (fgets (buf, 128, file) != NULL) { if (buf[0] == '#') continue; @@ -731,7 +652,7 @@ my_getid(const char *filename, char *name, uid_t id) return( TRUE); } } - fclose(stream); + fclose(file); return (-1); } @@ -763,4 +684,40 @@ my_getgrgid(char* group, gid_t gid) #endif + +#if !defined BB_REGEXP && (defined BB_GREP || defined BB_FIND ) +/* This tries to find a needle in a haystack, but does so by + * only trying to match literal strings (look 'ma, no regexps!) + * This is short, sweet, and carries _very_ little baggage, + * unlike its beefier cousin a few lines down... + * -Erik Andersen + */ +extern int find_match(char *haystack, char *needle, int ignoreCase) +{ + + if (ignoreCase == FALSE) { + haystack = strstr (haystack, needle); + if (haystack == NULL) + return FALSE; + return TRUE; + } else { + int i; + char needle1[BUF_SIZE]; + char haystack1[BUF_SIZE]; + + strncpy( haystack1, haystack, sizeof(haystack1)); + strncpy( needle1, needle, sizeof(needle1)); + for( i=0; i<sizeof(haystack1) && haystack1[i]; i++) + haystack1[i]=tolower( haystack1[i]); + for( i=0; i<sizeof(needle1) && needle1[i]; i++) + needle1[i]=tolower( needle1[i]); + haystack = strstr (haystack1, needle1); + if (haystack == NULL) + return FALSE; + return TRUE; + } +} +#endif + /* END CODE */ + |