Return to ulimit.c CVS log

Up to [MW Coherent from dump] / coherent / a / usr / bob / korn

Annotation of coherent/a/usr/bob/korn/ulimit.c, revision 1.1

1.1     ! root        1: /*
        !             2:        ulimit -- handle "ulimit" builtin
        !             3: 
        !             4:        Eric Gisin, September 1988
        !             5:        Adapted to PD KornShell. Removed AT&T code.
        !             6: 
        !             7:        last edit:      06-Jun-1987     D A Gwyn
        !             8: 
        !             9:        This started out as the BRL UNIX System V system call emulation
        !            10:        for 4.nBSD, and was later extended by Doug Kingston to handle
        !            11:        the extended 4.nBSD resource limits.  It now includes the code
        !            12:        that was originally under case SYSULIMIT in source file "xec.c".
        !            13: */
        !            14: 
        !            15: static char *RCSid = "$Header: ulimit.c,v 3.1 88/11/03 09:18:11 egisin Exp $";
        !            16: 
        !            17: #include <stddef.h>
        !            18: #include <errno.h>
        !            19: #include <signal.h>
        !            20: #include <setjmp.h>
        !            21: #if defined(_BSD) || defined(_BSD_SYSV)
        !            22: #include <sys/time.h>
        !            23: #include <sys/resource.h>
        !            24: #else
        !            25: #define        RLIMIT_FSIZE    2
        !            26: #endif
        !            27: #include "sh.h"
        !            28: 
        !            29: extern long ulimit();
        !            30: 
        !            31: int
        !            32: do_ulimit(a1, a2)
        !            33:        char    *a1, *a2;
        !            34: {
        !            35:        register int    c;
        !            36:        long            i;
        !            37: #if defined(_BSD) || defined(_BSD_SYSV)
        !            38:        struct rlimit   limit;          /* data being gotten/set */
        !            39:        int             softonly = 0;   /* set => soft limit, clear => hard limit */
        !            40:        int             factor = 1024;  /* unit scaling (1K or 1) */
        !            41: #endif
        !            42:        int     command = RLIMIT_FSIZE;
        !            43: 
        !            44:        if (a1 && (*a1 == '-'))         /* DAG -- Gould added first test */
        !            45:        {       c = *++a1;              /* DAG */
        !            46: #if defined(_BSD) || defined(_BSD_SYSV)
        !            47:                if (c >= 'A' && c <= 'Z')
        !            48:                {
        !            49:                        ++softonly;
        !            50:                        c += 'a' - 'A'; /* DAG -- map to lower-case */
        !            51:                }
        !            52: #endif
        !            53:                switch(c)
        !            54:                {
        !            55: #if defined(_BSD) || defined(_BSD_SYSV)
        !            56:                        case 'c':
        !            57:                                command = RLIMIT_CORE;
        !            58:                                break;
        !            59:                        case 'd':
        !            60:                                command = RLIMIT_DATA;
        !            61:                                break;
        !            62:                        case 'm':
        !            63:                                command = RLIMIT_RSS;
        !            64:                                break;
        !            65:                        case 's':
        !            66:                                command = RLIMIT_STACK;
        !            67:                                break;
        !            68:                        case 't':
        !            69:                                factor = 1;
        !            70:                                command = RLIMIT_CPU;
        !            71:                                break;
        !            72: #endif /* _BSD || _BSD_SYSV */
        !            73:                        case 'f':
        !            74:                                command = RLIMIT_FSIZE;
        !            75: #if _BSD_SYSV
        !            76:                                factor = 512;
        !            77: #endif
        !            78:                                break;
        !            79:                        default:
        !            80: #if _BSD
        !            81:                                errorf("Usage: %s [-cdmstf] [limit]\n", "ulimit");
        !            82: #else
        !            83:                                errorf("Usage: %s [-f] [limit]\n", "ulimit");
        !            84: #endif
        !            85:                }
        !            86:                a1 = a2;
        !            87:        }
        !            88:        if (a1)
        !            89:        {
        !            90:                i = 0;
        !            91:                while ((c = *a1++) >= '0' && c <= '9')
        !            92:                {
        !            93:                        i = (i * 10) + (long)(c - '0');
        !            94:                        if (i < 0)
        !            95:                                goto Error;
        !            96:                }
        !            97:                if (c || i < 0)
        !            98:                        goto Error;
        !            99:        }
        !           100: #if !(defined(_BSD) || defined(_BSD_SYSV))
        !           101:        else
        !           102:        {
        !           103:                i = -1;
        !           104:                command--;
        !           105:        }
        !           106: 
        !           107: #if !COHERENT
        !           108:        if ((i = ulimit(command, i)) < 0L)
        !           109:                goto Error;
        !           110:        if (command != RLIMIT_FSIZE)
        !           111:                shellf("%ld\n", i);
        !           112: #endif
        !           113: #else                                  /* DPK -- generalized for 4.nBSD: */
        !           114:        if (getrlimit(command, &limit))
        !           115:                goto Error;     /* errno is already set */
        !           116: 
        !           117:        if (a1)
        !           118:        {
        !           119:                limit.rlim_cur = i * factor;
        !           120: 
        !           121:                if (!softonly)
        !           122:                        limit.rlim_max = limit.rlim_cur;
        !           123: 
        !           124:                if (setrlimit(command, &limit))
        !           125:                        goto Error;
        !           126:        }
        !           127:        else
        !           128:        {
        !           129:                i = softonly ? limit.rlim_cur : limit.rlim_max;
        !           130: #if _BSD                       /* DAG -- System V always prints an integer */
        !           131:                if (i == RLIM_INFINITY)
        !           132:                        shellf("unlimited\n");
        !           133:                else
        !           134: #endif
        !           135:                        shellf("%ld\n", i/factor);
        !           136:        }
        !           137: #endif /* _BSD || _BSD_SYSV */
        !           138:        return 0;
        !           139: 
        !           140:   Error:
        !           141:        errorf("bad ulimit\n");
        !           142: }
        !           143: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.