diff options
Diffstat (limited to 'contrib/opie/libmissing')
22 files changed, 1392 insertions, 0 deletions
diff --git a/contrib/opie/libmissing/Makefile.in b/contrib/opie/libmissing/Makefile.in new file mode 100644 index 0000000..e00ead3 --- /dev/null +++ b/contrib/opie/libmissing/Makefile.in @@ -0,0 +1,30 @@ +## +# Makefile.in/Makefile: Directions for building libmissing. +# +# %%% copyright-cmetz +# This software is Copyright 1996 by Craig Metz, All Rights Reserved. +# The Inner Net License Version 2 applies to this software. +# You should have received a copy of the license with this software. If +# you didn't get a copy, you may request one from <license@inner.net>. +# +# History: +# +# Created by cmetz for OPIE 2.3 using old Makefiles as a guide. + +OBJS=bogus.o @MISSING@ + +CC=@CC@ +CFLAGS=$(CFL) -I.. +TARGET=libmissing.a + +all: $(TARGET) + +$(TARGET): $(OBJS) + ar r $(TARGET) $(OBJS) + @RANLIB@ $(TARGET) + +clean: + -rm -f $(OBJS) $(TARGET) + +realclean: clean + -rm -f *~ core* "\#*\#" *.o *.a Makefile diff --git a/contrib/opie/libmissing/alloca.c b/contrib/opie/libmissing/alloca.c new file mode 100644 index 0000000..61f2eeb --- /dev/null +++ b/contrib/opie/libmissing/alloca.c @@ -0,0 +1,494 @@ +/* alloca.c -- allocate automatically reclaimed memory + (Mostly) portable public-domain implementation -- D A Gwyn + + This implementation of the PWB library alloca function, + which is used to allocate space off the run-time stack so + that it is automatically reclaimed upon procedure exit, + was inspired by discussions with J. Q. Johnson of Cornell. + J.Otto Tennant <jot@cray.com> contributed the Cray support. + + There are some preprocessor constants that can + be defined when compiling for your specific system, for + improved efficiency; however, the defaults should be okay. + + The general concept of this implementation is to keep + track of all alloca-allocated blocks, and reclaim any + that are found to be deeper in the stack than the current + invocation. This heuristic does not reclaim storage as + soon as it becomes invalid, but it will do so eventually. + + As a special case, alloca(0) reclaims storage without + allocating any. It is a good idea to use alloca(0) in + your main control loop, etc. to force garbage collection. */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#ifdef emacs +#include "blockinput.h" +#endif + +/* If compiling with GCC 2, this file's not needed. */ +#if !defined (__GNUC__) || __GNUC__ < 2 + +/* If someone has defined alloca as a macro, + there must be some other way alloca is supposed to work. */ +#ifndef alloca + +#ifdef emacs +#ifdef static +/* actually, only want this if static is defined as "" + -- this is for usg, in which emacs must undefine static + in order to make unexec workable + */ +#ifndef STACK_DIRECTION +you +lose +-- must know STACK_DIRECTION at compile-time +#endif /* STACK_DIRECTION undefined */ +#endif /* static */ +#endif /* emacs */ + +/* If your stack is a linked list of frames, you have to + provide an "address metric" ADDRESS_FUNCTION macro. */ + +#if defined (CRAY) && defined (CRAY_STACKSEG_END) +long i00afunc (); +#define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg)) +#else +#define ADDRESS_FUNCTION(arg) &(arg) +#endif + +#if __STDC__ +typedef void *pointer; +#else +typedef char *pointer; +#endif + +#define NULL 0 + +/* Different portions of Emacs need to call different versions of + malloc. The Emacs executable needs alloca to call xmalloc, because + ordinary malloc isn't protected from input signals. On the other + hand, the utilities in lib-src need alloca to call malloc; some of + them are very simple, and don't have an xmalloc routine. + + Non-Emacs programs expect this to call use xmalloc. + + Callers below should use malloc. */ + +#if 0 +#ifndef emacs +#define malloc xmalloc +#endif +extern pointer malloc (); +#endif /* 0 */ + +/* Define STACK_DIRECTION if you know the direction of stack + growth for your system; otherwise it will be automatically + deduced at run-time. + + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown */ + +#ifndef STACK_DIRECTION +#define STACK_DIRECTION 0 /* Direction unknown. */ +#endif + +#if STACK_DIRECTION != 0 + +#define STACK_DIR STACK_DIRECTION /* Known at compile-time. */ + +#else /* STACK_DIRECTION == 0; need run-time code. */ + +static int stack_dir; /* 1 or -1 once known. */ +#define STACK_DIR stack_dir + +static void +find_stack_direction () +{ + static char *addr = NULL; /* Address of first `dummy', once known. */ + auto char dummy; /* To get stack address. */ + + if (addr == NULL) + { /* Initial entry. */ + addr = ADDRESS_FUNCTION (dummy); + + find_stack_direction (); /* Recurse once. */ + } + else + { + /* Second entry. */ + if (ADDRESS_FUNCTION (dummy) > addr) + stack_dir = 1; /* Stack grew upward. */ + else + stack_dir = -1; /* Stack grew downward. */ + } +} + +#endif /* STACK_DIRECTION == 0 */ + +/* An "alloca header" is used to: + (a) chain together all alloca'ed blocks; + (b) keep track of stack depth. + + It is very important that sizeof(header) agree with malloc + alignment chunk size. The following default should work okay. */ + +#ifndef ALIGN_SIZE +#define ALIGN_SIZE sizeof(double) +#endif + +typedef union hdr +{ + char align[ALIGN_SIZE]; /* To force sizeof(header). */ + struct + { + union hdr *next; /* For chaining headers. */ + char *deep; /* For stack depth measure. */ + } h; +} header; + +static header *last_alloca_header = NULL; /* -> last alloca header. */ + +/* Return a pointer to at least SIZE bytes of storage, + which will be automatically reclaimed upon exit from + the procedure that called alloca. Originally, this space + was supposed to be taken from the current stack frame of the + caller, but that method cannot be made to work for some + implementations of C, for example under Gould's UTX/32. */ + +pointer +alloca (size) + unsigned size; +{ + auto char probe; /* Probes stack depth: */ + register char *depth = ADDRESS_FUNCTION (probe); + +#if STACK_DIRECTION == 0 + if (STACK_DIR == 0) /* Unknown growth direction. */ + find_stack_direction (); +#endif + + /* Reclaim garbage, defined as all alloca'd storage that + was allocated from deeper in the stack than currently. */ + + { + register header *hp; /* Traverses linked list. */ + +#ifdef emacs + BLOCK_INPUT; +#endif + + for (hp = last_alloca_header; hp != NULL;) + if ((STACK_DIR > 0 && hp->h.deep > depth) + || (STACK_DIR < 0 && hp->h.deep < depth)) + { + register header *np = hp->h.next; + + free ((pointer) hp); /* Collect garbage. */ + + hp = np; /* -> next header. */ + } + else + break; /* Rest are not deeper. */ + + last_alloca_header = hp; /* -> last valid storage. */ + +#ifdef emacs + UNBLOCK_INPUT; +#endif + } + + if (size == 0) + return NULL; /* No allocation required. */ + + /* Allocate combined header + user data storage. */ + + { + register pointer new = malloc (sizeof (header) + size); + /* Address of header. */ + + ((header *) new)->h.next = last_alloca_header; + ((header *) new)->h.deep = depth; + + last_alloca_header = (header *) new; + + /* User storage begins just after header. */ + + return (pointer) ((char *) new + sizeof (header)); + } +} + +#if defined (CRAY) && defined (CRAY_STACKSEG_END) + +#ifdef DEBUG_I00AFUNC +#include <stdio.h> +#endif + +#ifndef CRAY_STACK +#define CRAY_STACK +#ifndef CRAY2 +/* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */ +struct stack_control_header + { + long shgrow:32; /* Number of times stack has grown. */ + long shaseg:32; /* Size of increments to stack. */ + long shhwm:32; /* High water mark of stack. */ + long shsize:32; /* Current size of stack (all segments). */ + }; + +/* The stack segment linkage control information occurs at + the high-address end of a stack segment. (The stack + grows from low addresses to high addresses.) The initial + part of the stack segment linkage control information is + 0200 (octal) words. This provides for register storage + for the routine which overflows the stack. */ + +struct stack_segment_linkage + { + long ss[0200]; /* 0200 overflow words. */ + long sssize:32; /* Number of words in this segment. */ + long ssbase:32; /* Offset to stack base. */ + long:32; + long sspseg:32; /* Offset to linkage control of previous + segment of stack. */ + long:32; + long sstcpt:32; /* Pointer to task common address block. */ + long sscsnm; /* Private control structure number for + microtasking. */ + long ssusr1; /* Reserved for user. */ + long ssusr2; /* Reserved for user. */ + long sstpid; /* Process ID for pid based multi-tasking. */ + long ssgvup; /* Pointer to multitasking thread giveup. */ + long sscray[7]; /* Reserved for Cray Research. */ + long ssa0; + long ssa1; + long ssa2; + long ssa3; + long ssa4; + long ssa5; + long ssa6; + long ssa7; + long sss0; + long sss1; + long sss2; + long sss3; + long sss4; + long sss5; + long sss6; + long sss7; + }; + +#else /* CRAY2 */ +/* The following structure defines the vector of words + returned by the STKSTAT library routine. */ +struct stk_stat + { + long now; /* Current total stack size. */ + long maxc; /* Amount of contiguous space which would + be required to satisfy the maximum + stack demand to date. */ + long high_water; /* Stack high-water mark. */ + long overflows; /* Number of stack overflow ($STKOFEN) calls. */ + long hits; /* Number of internal buffer hits. */ + long extends; /* Number of block extensions. */ + long stko_mallocs; /* Block allocations by $STKOFEN. */ + long underflows; /* Number of stack underflow calls ($STKRETN). */ + long stko_free; /* Number of deallocations by $STKRETN. */ + long stkm_free; /* Number of deallocations by $STKMRET. */ + long segments; /* Current number of stack segments. */ + long maxs; /* Maximum number of stack segments so far. */ + long pad_size; /* Stack pad size. */ + long current_address; /* Current stack segment address. */ + long current_size; /* Current stack segment size. This + number is actually corrupted by STKSTAT to + include the fifteen word trailer area. */ + long initial_address; /* Address of initial segment. */ + long initial_size; /* Size of initial segment. */ + }; + +/* The following structure describes the data structure which trails + any stack segment. I think that the description in 'asdef' is + out of date. I only describe the parts that I am sure about. */ + +struct stk_trailer + { + long this_address; /* Address of this block. */ + long this_size; /* Size of this block (does not include + this trailer). */ + long unknown2; + long unknown3; + long link; /* Address of trailer block of previous + segment. */ + long unknown5; + long unknown6; + long unknown7; + long unknown8; + long unknown9; + long unknown10; + long unknown11; + long unknown12; + long unknown13; + long unknown14; + }; + +#endif /* CRAY2 */ +#endif /* not CRAY_STACK */ + +#ifdef CRAY2 +/* Determine a "stack measure" for an arbitrary ADDRESS. + I doubt that "lint" will like this much. */ + +static long +i00afunc (long *address) +{ + struct stk_stat status; + struct stk_trailer *trailer; + long *block, size; + long result = 0; + + /* We want to iterate through all of the segments. The first + step is to get the stack status structure. We could do this + more quickly and more directly, perhaps, by referencing the + $LM00 common block, but I know that this works. */ + + STKSTAT (&status); + + /* Set up the iteration. */ + + trailer = (struct stk_trailer *) (status.current_address + + status.current_size + - 15); + + /* There must be at least one stack segment. Therefore it is + a fatal error if "trailer" is null. */ + + if (trailer == 0) + abort (); + + /* Discard segments that do not contain our argument address. */ + + while (trailer != 0) + { + block = (long *) trailer->this_address; + size = trailer->this_size; + if (block == 0 || size == 0) + abort (); + trailer = (struct stk_trailer *) trailer->link; + if ((block <= address) && (address < (block + size))) + break; + } + + /* Set the result to the offset in this segment and add the sizes + of all predecessor segments. */ + + result = address - block; + + if (trailer == 0) + { + return result; + } + + do + { + if (trailer->this_size <= 0) + abort (); + result += trailer->this_size; + trailer = (struct stk_trailer *) trailer->link; + } + while (trailer != 0); + + /* We are done. Note that if you present a bogus address (one + not in any segment), you will get a different number back, formed + from subtracting the address of the first block. This is probably + not what you want. */ + + return (result); +} + +#else /* not CRAY2 */ +/* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP. + Determine the number of the cell within the stack, + given the address of the cell. The purpose of this + routine is to linearize, in some sense, stack addresses + for alloca. */ + +static long +i00afunc (long address) +{ + long stkl = 0; + + long size, pseg, this_segment, stack; + long result = 0; + + struct stack_segment_linkage *ssptr; + + /* Register B67 contains the address of the end of the + current stack segment. If you (as a subprogram) store + your registers on the stack and find that you are past + the contents of B67, you have overflowed the segment. + + B67 also points to the stack segment linkage control + area, which is what we are really interested in. */ + + stkl = CRAY_STACKSEG_END (); + ssptr = (struct stack_segment_linkage *) stkl; + + /* If one subtracts 'size' from the end of the segment, + one has the address of the first word of the segment. + + If this is not the first segment, 'pseg' will be + nonzero. */ + + pseg = ssptr->sspseg; + size = ssptr->sssize; + + this_segment = stkl - size; + + /* It is possible that calling this routine itself caused + a stack overflow. Discard stack segments which do not + contain the target address. */ + + while (!(this_segment <= address && address <= stkl)) + { +#ifdef DEBUG_I00AFUNC + fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl); +#endif + if (pseg == 0) + break; + stkl = stkl - pseg; + ssptr = (struct stack_segment_linkage *) stkl; + size = ssptr->sssize; + pseg = ssptr->sspseg; + this_segment = stkl - size; + } + + result = address - this_segment; + + /* If you subtract pseg from the current end of the stack, + you get the address of the previous stack segment's end. + This seems a little convoluted to me, but I'll bet you save + a cycle somewhere. */ + + while (pseg != 0) + { +#ifdef DEBUG_I00AFUNC + fprintf (stderr, "%011o %011o\n", pseg, size); +#endif + stkl = stkl - pseg; + ssptr = (struct stack_segment_linkage *) stkl; + size = ssptr->sssize; + pseg = ssptr->sspseg; + result += size; + } + return (result); +} + +#endif /* not CRAY2 */ +#endif /* CRAY */ + +#endif /* no alloca */ +#endif /* not GCC version 2 */ diff --git a/contrib/opie/libmissing/bogus.c b/contrib/opie/libmissing/bogus.c new file mode 100644 index 0000000..68dcc54 --- /dev/null +++ b/contrib/opie/libmissing/bogus.c @@ -0,0 +1 @@ +int _bogus; diff --git a/contrib/opie/libmissing/endutent.c b/contrib/opie/libmissing/endutent.c new file mode 100644 index 0000000..4a4051c --- /dev/null +++ b/contrib/opie/libmissing/endutent.c @@ -0,0 +1,18 @@ +/* endutent.c: A replacement for the endutent function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.3. +*/ +#include "opie_cfg.h" +#include "opie.h" + +void endutent FUNCTION_NOARGS +{ +} diff --git a/contrib/opie/libmissing/env.c b/contrib/opie/libmissing/env.c new file mode 100644 index 0000000..9a445a0 --- /dev/null +++ b/contrib/opie/libmissing/env.c @@ -0,0 +1,141 @@ +/* env.c: Replacement environment handling functions. + +%%% portions-copyright-cmetz +Portions of this software are Copyright 1996 by Craig Metz, All Rights +Reserved. The Inner Net License Version 2 applies to these portions of +the software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + +Portions of this software are Copyright 1995 by Randall Atkinson and Dan +McDonald, All Rights Reserved. All Rights under this copyright are assigned +to the U.S. Naval Research Laboratory (NRL). The NRL Copyright Notice and +License Agreement applies to this software. + + History: + + Modified by cmetz for OPIE 2.2. Changed ifdefs for libmissing. + Combined all env functions and made _findenv static. + Including headers is a good idea, though. Add more headers. + Modified at NRL for OPIE 2.0. + Originally from BSD. +*/ +/* + * Copyright (c) 1987 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by the University of California, Berkeley. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ + +#include "opie_cfg.h" +#include <stdio.h> +#if HAVE_UNISTD_H +#include <unistd.h> +#endif /* HAVE_UNISTD_H */ +#if HAVE_STDLIB_H +#include <stdlib.h> +#endif /* HAVE_STDLIB_H */ +#include "opie.h" + +static char *_findenv FUNCTION((name, offset), register char *name AND int *offset) +{ + extern char **environ; + register int len; + register char **P, *C; + + for (C = name, len = 0; *C && *C != '='; ++C, ++len); + for (P = environ; *P; ++P) + if (!strncmp(*P, name, len)) + if (*(C = *P + len) == '=') { + *offset = P - environ; + return (++C); + } + return (NULL); +} + +#if !HAVE_GETENV +char *getenv FUNCTION((name), char *name) +{ + int offset; + char *_findenv(); + + return (_findenv(name, &offset)); +} +#endif /* !HAVE_GETENV */ + +#if !HAVE_SETENV +int setenv FUNCTION((name, value, rewrite), char *name AND char *value AND int rewrite) +{ + extern char **environ; + static int alloced; /* if allocated space before */ + register char *C; + int l_value, offset; + + if (*value == '=') /* no `=' in value */ + ++value; + l_value = strlen(value); + if ((C = _findenv(name, &offset))) { /* find if already exists */ + if (!rewrite) + return (0); + if (strlen(C) >= l_value) { /* old larger; copy over */ + while (*C++ = *value++); + return (0); + } + } else { /* create new slot */ + register int cnt; + register char **P; + + for (P = environ, cnt = 0; *P; ++P, ++cnt); + if (alloced) { /* just increase size */ + environ = (char **) realloc((char *) environ, + (u_int) (sizeof(char *) * (cnt + 2))); + + if (!environ) + return (-1); + } else { /* get new space */ + alloced = 1; /* copy old entries into it */ + P = (char **) malloc((u_int) (sizeof(char *) * + (cnt + 2))); + + if (!P) + return (-1); + strncpy(P, environ, cnt * sizeof(char *)); + + environ = P; + } + environ[cnt + 1] = NULL; + offset = cnt; + } + for (C = name; *C && *C != '='; ++C); /* no `=' in name */ + if (!(environ[offset] = /* name + `=' + value */ + malloc((u_int) ((int) (C - name) + l_value + 2)))) + return (-1); + for (C = environ[offset]; (*C = *name++) && *C != '='; ++C); + for (*C++ = '='; *C++ = *value++;); + return (0); +} +#endif /* !HAVE_SETENV */ + +#if !HAVE_UNSETENV +VOIDRET unsetenv FUNCTION((name), char *name) +{ + extern char **environ; + register char **P; + int offset; + + while (_findenv(name, &offset)) /* if set multiple times */ + for (P = &environ[offset];; ++P) + if (!(*P = *(P + 1))) + break; +} +#endif /* !HAVE_UNSETENV */ diff --git a/contrib/opie/libmissing/getcwd.c b/contrib/opie/libmissing/getcwd.c new file mode 100644 index 0000000..30ccdc0 --- /dev/null +++ b/contrib/opie/libmissing/getcwd.c @@ -0,0 +1,23 @@ +/* getcwd.c: A replacement for the getcwd function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.3. +*/ +#include "opie_cfg.h" +#include "opie.h" + +char *getcwd FUNCTION((c, l), char *c AND int l) +{ +#if HAVE_GETWD + return getwd(c); +#else /* HAVE_INDEX */ +#error Need getwd() to build a replacement getcwd() +#endif /* HAVE_INDEX */ +} diff --git a/contrib/opie/libmissing/getusershell.c b/contrib/opie/libmissing/getusershell.c new file mode 100644 index 0000000..885aa04 --- /dev/null +++ b/contrib/opie/libmissing/getusershell.c @@ -0,0 +1,67 @@ +/* getusershell.c: minimal implementation of the getusershell() and + endusershell() library routines for systems that don't have them. + +%%% portions-copyright-cmetz +Portions of this software are Copyright 1996 by Craig Metz, All Rights +Reserved. The Inner Net License Version 2 applies to these portions of +the software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + +Portions of this software are Copyright 1995 by Randall Atkinson and Dan +McDonald, All Rights Reserved. All Rights under this copyright are assigned +to the U.S. Naval Research Laboratory (NRL). The NRL Copyright Notice and +License Agreement applies to this software. + + History: + + Modified by cmetz for OPIE 2.2. Use FUNCTION declaration et al. + Modified at NRL for OPIE 2.1. Remove trailing newlines from + /etc/shells entries. Fixed infinite loop. Fixed a bug + where second invocation on would fail. + Written at NRL for OPIE 2.0. +*/ +#include "opie_cfg.h" +#include <stdio.h> +#if HAVE_STRING_H +#include <string.h> +#endif /* HAVE_STRING_H */ +#include "opie.h" + +static FILE *fh = NULL; +static char *internal[] = {"/bin/sh", "/bin/csh", NULL}; +static int i = 0; +static char buffer[1024]; + +char *getusershell FUNCTION_NOARGS +{ + char *c; + + if (!fh) + fh = fopen("/etc/shells", "r"); + + if (fh) { + if (fgets(buffer, sizeof(buffer), fh)) { + if (c = strchr(buffer, '\n')) + *c = 0; + return buffer; + } else { + fclose(fh); + return NULL; + } + } else { + if (internal[i]) + return internal[i++]; + else + return NULL; + } +} + +VOIDRET endusershell FUNCTION_NOARGS +{ + if (fh) { + fclose(fh); + fh = NULL; + } + i = 0; +} diff --git a/contrib/opie/libmissing/getutline.c b/contrib/opie/libmissing/getutline.c new file mode 100644 index 0000000..9653950 --- /dev/null +++ b/contrib/opie/libmissing/getutline.c @@ -0,0 +1,50 @@ +/* getutline.c: A replacement for the getutline() function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.3. +*/ + +#include "opie_cfg.h" +#include <stdio.h> +#include <utmp.h> +#include "opie.h" + +static struct utmp u; + +struct utmp *getutline FUNCTION((utmp), struct utmp *utmp) +{ + FILE *f; + int i; + + if (!(f = __opieopen(_PATH_UTMP, 0, 0644))) + return 0; + +#if HAVE_TTYSLOT + if (i = ttyslot()) { + if (fseek(f, i * sizeof(struct utmp), SEEK_SET) < 0) + goto ret; + if (fread(&u, sizeof(struct utmp), 1, f) != sizeof(struct utmp)) + goto ret; + fclose(f); + return &u; + } +#endif /* HAVE_TTYSLOT */ + + while(fread(&u, sizeof(struct utmp), 1, f) == sizeof(struct utmp)) { + if (!strncmp(utmp->ut_line, u.ut_line, sizeof(u.ut_line) - 1)) { + fclose(f); + return &u; + } + } + +ret: + fclose(f); + return NULL; +} diff --git a/contrib/opie/libmissing/initgroups.c b/contrib/opie/libmissing/initgroups.c new file mode 100644 index 0000000..2306a0c --- /dev/null +++ b/contrib/opie/libmissing/initgroups.c @@ -0,0 +1,129 @@ +/* initgroups.c: Replacement for the initgroups() function. + +%%% portions-copyright-cmetz +Portions of this software are Copyright 1996 by Craig Metz, All Rights +Reserved. The Inner Net License Version 2 applies to these portions of +the software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Modified by cmetz for OPIE 2.2. Removed useless string. + Ifdef around headers. Use FUNCTION declarations. + Not everyone has multiple groups. Work around + lack of NGROUPS. + Originally from 4.3BSD Net/2. +*/ +/* + * Copyright (c) 1983 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* + * initgroups + */ +#include "opie_cfg.h" + +#if HAVE_SYS_PARAM_H +#include <sys/param.h> +#endif /* HAVE_SYS_PARAM_H */ +#include <stdio.h> +#if HAVE_STRING_H +#include <string.h> +#endif /* HAVE_STRING */ +#if HAVE_UNISTD_H +#include <unistd.h> +#endif /* HAVE_UNISTD_H */ +#include <grp.h> + +#include "opie.h" + +struct group *getgrent(); + +int initgroups FUNCTION((uname, agroup), const char *uname AND int agroup) +{ +#if HAVE_SETGROUPS && HAVE_GETGROUPS +#if NGROUPS + int groups[NGROUPS]; +#else /* NGROUPS */ +#define STARTING_NGROUPS 32 + int groups[STARTING_NGROUPS]; +#endif /* NGROUPS */ + int ngroups; + register struct group *grp; + register int i; + + /* + * If installing primary group, duplicate it; + * the first element of groups is the effective gid + * and will be overwritten when a setgid file is executed. + */ + if (agroup >= 0) { + groups[ngroups++] = agroup; + groups[ngroups++] = agroup; + } + setgrent(); + while (grp = getgrent()) { + if (grp->gr_gid == agroup) + continue; + for (i = 0; grp->gr_mem[i]; i++) + if (!strcmp(grp->gr_mem[i], uname)) { +#if NGROUPS + if (ngroups == NGROUPS) { +#else /* NGROUPS */ + if (ngroups == STARTING_NGROUPS) { +#endif /* NGROUPS */ +fprintf(stderr, "initgroups: %s is in too many groups\n", uname); + goto toomany; + } + groups[ngroups++] = grp->gr_gid; + } + } +toomany: + endgrent(); +#if NGROUPS + if (setgroups(ngroups, groups) < 0) { + perror("setgroups"); + return (-1); + } +#else /* NGROUPS */ + ngroups++; + do { + if ((i = setgroups(--ngroups, groups) < 0) && (i != EINVAL)) { + perror("setgroups"); + return (-1); + } + } while ((i < 0) && (ngroups > 0)); +#endif /* NGROUPS */ +#endif /* HAVE_SETGROUPS && HAVE_GETGROUPS */ + return (0); +} diff --git a/contrib/opie/libmissing/memcmp.c b/contrib/opie/libmissing/memcmp.c new file mode 100644 index 0000000..e19beaf --- /dev/null +++ b/contrib/opie/libmissing/memcmp.c @@ -0,0 +1,25 @@ +/* strncasecmp.c: A replacement for the strncasecmp function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.2. +*/ +#include "opie_cfg.h" +#include "opie.h" + +int memcmp FUNCTION((s1, s2, n), unsigned char *s1 AND unsigned char *s2 AND int n) +{ + while(n--) { + if (*s1 != *s2) + return (*s1 > *s2) ? 1 : -1; + s1++; + s2++; + } + return 0; +} diff --git a/contrib/opie/libmissing/memcpy.c b/contrib/opie/libmissing/memcpy.c new file mode 100644 index 0000000..6d386c2 --- /dev/null +++ b/contrib/opie/libmissing/memcpy.c @@ -0,0 +1,25 @@ +/* memcpy.c: A replacement for the memcpy function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.2. +*/ +#include "opie_cfg.h" +#include "opie.h" + +VOIDPTR *memcpy FUNCTION((d, s, n), unsigned char *d AND unsigned char *s AND int n) +{ +#if HAVE_BCOPY + bcopy(s, d, n); +#else /* HAVE_BCOPY */ + char *d2 = d; + while(n--) (*d2++) = (*s++); +#endif /* HAVE_BCOPY */ + return d; +} diff --git a/contrib/opie/libmissing/memset.c b/contrib/opie/libmissing/memset.c new file mode 100644 index 0000000..678c441 --- /dev/null +++ b/contrib/opie/libmissing/memset.c @@ -0,0 +1,21 @@ +/* memcpy.c: A replacement for the memcpy function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.2. +*/ +#include "opie_cfg.h" +#include "opie.h" + +VOIDPTR *memset FUNCTION((d, v, n), unsigned char *d AND int v AND int n) +{ + unsigned char *d2 = d; + while(n--) (*d2++) = (unsigned char)v; + return d; +} diff --git a/contrib/opie/libmissing/pututline.c b/contrib/opie/libmissing/pututline.c new file mode 100644 index 0000000..62da458 --- /dev/null +++ b/contrib/opie/libmissing/pututline.c @@ -0,0 +1,56 @@ +/* pututline.c: A replacement for the pututline() function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.3. +*/ + +#include "opie_cfg.h" +#include <stdio.h> +#include <utmp.h> +#include "opie.h" + +void pututline FUNCTION((utmp), struct utmp *utmp) +{ + FILE *f; + struct utmp u; + int i; + + if (!(f = __opieopen(_PATH_UTMP, 1, 0644))) + return; + +#if HAVE_TTYSLOT + if (i = ttyslot()) { + if (fseek(f, i * sizeof(struct utmp), SEEK_SET) < 0) + goto ret; + fwrite(utmp, sizeof(struct utmp), 1, f); + goto ret; + } +#endif /* HAVE_TTYSLOT */ + + while(fread(&u, sizeof(struct utmp), 1, f) == sizeof(struct utmp)) { + if (!strncmp(utmp->ut_line, u.ut_line, sizeof(u.ut_line) - 1)) { + if ((i = ftell(f)) < 0) + goto ret; + if (fseek(f, i - sizeof(struct utmp), SEEK_SET) < 0) + goto ret; + fwrite(utmp, sizeof(struct utmp), 1, f); + goto ret; + } + } + + fclose(f); + + if (!(f = __opieopen(_PATH_UTMP, 2, 0644))) + return; + fwrite(utmp, sizeof(struct utmp), 1, f); + +ret: + fclose(f); +} diff --git a/contrib/opie/libmissing/sigaddset.c b/contrib/opie/libmissing/sigaddset.c new file mode 100644 index 0000000..56a613b --- /dev/null +++ b/contrib/opie/libmissing/sigaddset.c @@ -0,0 +1,36 @@ +/* sigaddset.c: A replacement for the sigaddset function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.2. +*/ + +#include "opie_cfg.h" + +#ifndef _NSIG +#ifdef NSIG +#define _NSIG NSIG +#else /* NSIG */ +#define _NSIG 32 +#endif /* NSIG */ +#endif /* _NSIG */ + +#include "opie.h" + +int sigaddset FUNCTION((set, signum), sigset_t *set AND int signum) +{ +#if sizeof(sigset_t) != sizeof(int) +Sorry, we don't currently support your system. +#else /* sizeof(sigset_t) != sizeof(int) */ + if (set && (signum > 0) && (signum < _NSIG)) + *set |= 1 << (signum - 1); +#endif /* sizeof(sigset_t) != sizeof(int) */ + + return 0; +} diff --git a/contrib/opie/libmissing/sigemptyset.c b/contrib/opie/libmissing/sigemptyset.c new file mode 100644 index 0000000..fc083f5 --- /dev/null +++ b/contrib/opie/libmissing/sigemptyset.c @@ -0,0 +1,23 @@ +/* sigemptyset.c: A replacement for the sigemptyset function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.2. +*/ + +#include "opie_cfg.h" +#include "opie.h" + +int sigemptyset FUNCTION((set), sigset_t *set) +{ + if (set) + memset(set, 0, sizeof(sigset_t)) + + return 0; +} diff --git a/contrib/opie/libmissing/sigprocmask.c b/contrib/opie/libmissing/sigprocmask.c new file mode 100644 index 0000000..4af1559 --- /dev/null +++ b/contrib/opie/libmissing/sigprocmask.c @@ -0,0 +1,68 @@ +/* sigprocmask.c: A replacement for the sigprocmask() function + +%%% portions-copyright-cmetz +Portions of this software are Copyright 1996 by Craig Metz, All Rights +Reserved. The Inner Net License Version 2 applies to these portions of +the software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + +Portions of this software are Copyright 1995 by Randall Atkinson and Dan +McDonald, All Rights Reserved. All Rights under this copyright are assigned +to the U.S. Naval Research Laboratory (NRL). The NRL Copyright Notice and +License Agreement applies to this software. + + History: + + Created by cmetz for OPIE 2.2 from popen.c. Use FUNCTION + declaration et al. Include opie.h. +*/ + +#include "opie_cfg.h" + +#include <sys/types.h> +#if HAVE_SIGNAL_H +#include <signal.h> +#endif /* HAVE_SIGNAL_H */ +#if HAVE_SYS_SIGNAL_H +#include <sys/signal.h> +#endif /* HAVE_SYS_SIGNAL_H */ + +#if !HAVE_SIGBLOCK || !HAVE_SIGSETMASK +Without sigblock and sigsetmask, we can't build a replacement sigprocmask. +#endif /* !HAVE_SIGBLOCK || !HAVE_SIGSETMASK */ + +#include "opie.h" + +#ifndef sigset_t +#define sigset_t int +#endif /* sigset_t */ + +int sigprocmask FUNCTION((how, set, oset), int how AND sigset_t *set AND sigset_t *oset) +{ + int old, new; + + if (set && (set != (sigset_t *)SIG_IGN) && (set != (sigset_t *)SIG_ERR)) + new = *set; + else + new = 0; + + switch(how) { + case SIG_BLOCK: + old = sigblock(new); + if (oset && (oset != (sigset_t *)SIG_IGN) && (oset != (sigset_t *)SIG_ERR)) + *oset = old; + return 0; + + case SIG_SETMASK: + old = sigsetmask(new); + if (oset && (oset != (sigset_t *)SIG_IGN) && (oset != (sigset_t *)SIG_ERR)) + *oset = old; + return 0; + + case SIG_UNBLOCK: + /* not implemented */ + default: + return 0; + } +} diff --git a/contrib/opie/libmissing/strchr.c b/contrib/opie/libmissing/strchr.c new file mode 100644 index 0000000..2903bc4 --- /dev/null +++ b/contrib/opie/libmissing/strchr.c @@ -0,0 +1,24 @@ +/* strchr.c: A replacement for the strchr function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.3. +*/ +#include "opie_cfg.h" +#include "opie.h" + +char *strchr FUNCTION((s, c), char *s AND int c) +{ +#if HAVE_INDEX + return index(s, c); +#else /* HAVE_INDEX */ + while(*s && (*s != c)) s++; + return *s ? s : (char *)0; +#endif /* HAVE_INDEX */ +} diff --git a/contrib/opie/libmissing/strerror.c b/contrib/opie/libmissing/strerror.c new file mode 100644 index 0000000..89632f9 --- /dev/null +++ b/contrib/opie/libmissing/strerror.c @@ -0,0 +1,34 @@ +/* strerror.c: A replacement for the strerror function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.2. +*/ + +#include "opie_cfg.h" +#include "opie.h" + +char *strerror FUNCTION((errnum), int errnum) +{ +#if HAVE_SYS_ERRLIST + extern char *sys_errlist[]; + return sys_errlist[errnum]; +#else /* NEED_STRERROR */ +#if HAVE__SYS_ERRLIST + extern char *_sys_errlist[]; + return sys_errlist[errnum]; +#else /* HAVE__SYS_ERRLIST */ + static char hexdigits[] = "0123456789abcdef"; + static char buffer[] = "System error 0x42"; + buffer[15] = hexdigits[(errnum >> 4) & 0x0f]; + buffer[16] = hexdigits[errnum & 0x0f]; + return buffer; +#endif /* HAVE__SYS_ERRLIST */ +#endif /* NEED_STRERROR */ +} diff --git a/contrib/opie/libmissing/strncasecmp.c b/contrib/opie/libmissing/strncasecmp.c new file mode 100644 index 0000000..e90b4c0 --- /dev/null +++ b/contrib/opie/libmissing/strncasecmp.c @@ -0,0 +1,30 @@ +/* strncasecmp.c: A replacement for the strncasecmp function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.2. +*/ +#include "opie_cfg.h" +#include "opie.h" + +int strncasecmp FUNCTION((s1, s2, n), unsigned char *s1 AND unsigned char *s2 AND int n) +{ + unsigned char c1, c2; + while(*s1 && *s2 && n--) { + c1 = ((*s1 >= 'A') && (*s1 <= 'Z')) ? (*s1++) + ('a' - 'A') : (*s1++); + c2 = ((*s2 >= 'A') && (*s2 <= 'Z')) ? (*s2++) + ('a' - 'A') : (*s2++); + if (c1 != c2) + return (c1 > c2) ? 1 : -1; + } + if (*s1 && !*s2) + return 1; + if (!*s1 && *s2) + return -1; + return 0; +} diff --git a/contrib/opie/libmissing/strrchr.c b/contrib/opie/libmissing/strrchr.c new file mode 100644 index 0000000..04d46ce --- /dev/null +++ b/contrib/opie/libmissing/strrchr.c @@ -0,0 +1,25 @@ +/* strrchr.c: A replacement for the strrchr function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.3. +*/ +#include "opie_cfg.h" +#include "opie.h" + +char *strrchr FUNCTION((s, c), char *s AND int c) +{ +#if HAVE_RINDEX + return rindex(s, c); +#else /* HAVE_RINDEX */ + char *s2 = (char *)0; + while(*s) { if (*s == c) s2 = s; s++ }; + return s2; +#endif /* HAVE_RINDEX */ +} diff --git a/contrib/opie/libmissing/sysconf.c b/contrib/opie/libmissing/sysconf.c new file mode 100644 index 0000000..fb3a5bc --- /dev/null +++ b/contrib/opie/libmissing/sysconf.c @@ -0,0 +1,30 @@ +/* sysconf.c: A (partial) replacement for the sysconf function + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Created by cmetz for OPIE 2.3. +*/ +#include "opie_cfg.h" +#if HAVE_SYS_PARAM_H +#include <sys/param.h> +#endif /* HAVE_SYS_PARAM_H */ +#include "opie.h" + +long sysconf(int name) +{ + switch(name) { + case _SC_OPEN_MAX: +#if HAVE_GETDTABLESIZE + return getdtablesize(); +#else /* HAVE_GETDTABLESIZE */ +#error Need getdtablesize() to build a replacement sysconf() +#endif /* HAVE_GETDTABLESIZE */ + + return -1; +} diff --git a/contrib/opie/libmissing/uname.c b/contrib/opie/libmissing/uname.c new file mode 100644 index 0000000..5b51fa5 --- /dev/null +++ b/contrib/opie/libmissing/uname.c @@ -0,0 +1,42 @@ +/* uname.c: A replacement for the uname function (sort of) + +%%% copyright-cmetz +This software is Copyright 1996 by Craig Metz, All Rights Reserved. +The Inner Net License Version 2 applies to this software. +You should have received a copy of the license with this software. If +you didn't get a copy, you may request one from <license@inner.net>. + + History: + + Modified by cmetz for OPIE 2.3. Ifdef around gethostname(). + Created by cmetz for OPIE 2.2. +*/ +#include "opie_cfg.h" +#if HAVE_SYS_PARAM_H +#include <sys/param.h> +#endif /* HAVE_SYS_PARAM_H */ +#include "opie.h" + +int uname FUNCTION(struct utsname *buf) +{ +#if HAVE_GETHOSTNAME + char hostname[MAXHOSTNAMELEN], *c; + + memset(buf, 0, sizeof(buf)); + + if (gethostname(hostname, sizeof(hostname)-1) < 0) + return -1; + + hostname[sizeof(hostname) - 1] = 0; + + if (c = strchr(hostname, '.')) { + *c = 0; + } + + strncpy(buf->nodename, hostname, sizeof(buf->nodename) - 1); + return 0; +#else /* HAVE_GETHOSTNAME */ + strncpy(buf->nodename, "unknown", sizeof(buf->nodename) - 1); + return 0; +#endif /* HAVE_GETHOSTNAME */ +} |