posixlocks resource limit part 1/4: Add support to the login.conf database,
[dragonfly.git] / bin / sh / miscbltin.c
1 /*-
2  * Copyright (c) 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Kenneth Almquist.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)miscbltin.c      8.4 (Berkeley) 5/4/95
37  * $FreeBSD: src/bin/sh/miscbltin.c,v 1.22.2.3 2002/07/19 04:38:51 tjr Exp $
38  * $DragonFly: src/bin/sh/miscbltin.c,v 1.4 2004/04/22 16:52:53 dillon Exp $
39  */
40
41 /*
42  * Miscellaneous builtins.
43  */
44
45 #include <sys/types.h>
46 #include <sys/stat.h>
47 #include <sys/time.h>
48 #include <sys/resource.h>
49 #include <unistd.h>
50 #include <ctype.h>
51 #include <errno.h>
52 #include <stdio.h>
53 #include <stdlib.h>
54 #include <termios.h>
55
56 #include "shell.h"
57 #include "options.h"
58 #include "var.h"
59 #include "output.h"
60 #include "memalloc.h"
61 #include "error.h"
62 #include "mystring.h"
63
64 int readcmd(int, char **);
65 int umaskcmd(int, char **);
66 int ulimitcmd(int, char **);
67
68 #undef eflag
69
70 /*
71  * The read builtin.  The -r option causes backslashes to be treated like
72  * ordinary characters.
73  *
74  * This uses unbuffered input, which may be avoidable in some cases.
75  */
76
77 int
78 readcmd(int argc __unused, char **argv __unused)
79 {
80         char **ap;
81         int backslash;
82         char c;
83         int rflag;
84         const char *prompt;
85         char *ifs;
86         char *p;
87         int startword;
88         int status;
89         int i;
90         struct timeval tv;
91         char *tvptr;
92         fd_set ifds;
93         struct termios told, tnew;
94         int tsaved;
95
96         rflag = 0;
97         prompt = NULL;
98         tv.tv_sec = -1;
99         tv.tv_usec = 0;
100         while ((i = nextopt("erp:t:")) != '\0') {
101                 switch(i) {
102                 case 'p':
103                         prompt = shoptarg;
104                         break;
105                 case 'e':
106                         break;
107                 case 'r':
108                         rflag = 1;
109                         break;
110                 case 't':
111                         tv.tv_sec = strtol(shoptarg, &tvptr, 0);
112                         if (tvptr == shoptarg)
113                                 error("timeout value");
114                         switch(*tvptr) {
115                         case 0:
116                         case 's':
117                                 break;
118                         case 'h':
119                                 tv.tv_sec *= 60;
120                                 /* FALLTHROUGH */
121                         case 'm':
122                                 tv.tv_sec *= 60;
123                                 break;
124                         default:
125                                 error("timeout unit");
126                         }
127                         break;
128                 }
129         }
130         if (prompt && isatty(0)) {
131                 out2str(prompt);
132                 flushall();
133         }
134         if (*(ap = argptr) == NULL)
135                 error("arg count");
136         if ((ifs = bltinlookup("IFS", 1)) == NULL)
137                 ifs = nullstr;
138
139         if (tv.tv_sec >= 0) {
140                 /*
141                  * See if we can disable input processing; this will
142                  * not give the desired result if we are in a pipeline
143                  * and someone upstream is still in line-by-line mode.
144                  */
145                 tsaved = 0;
146                 if (tcgetattr(0, &told) == 0) {
147                         memcpy(&tnew, &told, sizeof(told));
148                         cfmakeraw(&tnew);
149                         tcsetattr(0, TCSANOW, &tnew);
150                         tsaved = 1;
151                 }
152                 /*
153                  * Wait for something to become available.
154                  */
155                 FD_ZERO(&ifds);
156                 FD_SET(0, &ifds);
157                 status = select(1, &ifds, NULL, NULL, &tv);
158                 if (tsaved)
159                         tcsetattr(0, TCSANOW, &told);
160                 /*
161                  * If there's nothing ready, return an error.
162                  */
163                 if (status <= 0)
164                         return(1);
165         }
166
167         status = 0;
168         startword = 1;
169         backslash = 0;
170         STARTSTACKSTR(p);
171         for (;;) {
172                 if (read(STDIN_FILENO, &c, 1) != 1) {
173                         status = 1;
174                         break;
175                 }
176                 if (c == '\0')
177                         continue;
178                 if (backslash) {
179                         backslash = 0;
180                         if (c != '\n')
181                                 STPUTC(c, p);
182                         continue;
183                 }
184                 if (!rflag && c == '\\') {
185                         backslash++;
186                         continue;
187                 }
188                 if (c == '\n')
189                         break;
190                 if (startword && *ifs == ' ' && strchr(ifs, c)) {
191                         continue;
192                 }
193                 startword = 0;
194                 if (backslash && c == '\\') {
195                         if (read(STDIN_FILENO, &c, 1) != 1) {
196                                 status = 1;
197                                 break;
198                         }
199                         STPUTC(c, p);
200                 } else if (ap[1] != NULL && strchr(ifs, c) != NULL) {
201                         STACKSTRNUL(p);
202                         setvar(*ap, stackblock(), 0);
203                         ap++;
204                         startword = 1;
205                         STARTSTACKSTR(p);
206                 } else {
207                         STPUTC(c, p);
208                 }
209         }
210         STACKSTRNUL(p);
211         setvar(*ap, stackblock(), 0);
212         while (*++ap != NULL)
213                 setvar(*ap, nullstr, 0);
214         return status;
215 }
216
217
218
219 int
220 umaskcmd(int argc __unused, char **argv)
221 {
222         char *ap;
223         int mask;
224         int i;
225         int symbolic_mode = 0;
226
227         while ((i = nextopt("S")) != '\0') {
228                 symbolic_mode = 1;
229         }
230
231         INTOFF;
232         mask = umask(0);
233         umask(mask);
234         INTON;
235
236         if ((ap = *argptr) == NULL) {
237                 if (symbolic_mode) {
238                         char u[4], g[4], o[4];
239
240                         i = 0;
241                         if ((mask & S_IRUSR) == 0)
242                                 u[i++] = 'r';
243                         if ((mask & S_IWUSR) == 0)
244                                 u[i++] = 'w';
245                         if ((mask & S_IXUSR) == 0)
246                                 u[i++] = 'x';
247                         u[i] = '\0';
248
249                         i = 0;
250                         if ((mask & S_IRGRP) == 0)
251                                 g[i++] = 'r';
252                         if ((mask & S_IWGRP) == 0)
253                                 g[i++] = 'w';
254                         if ((mask & S_IXGRP) == 0)
255                                 g[i++] = 'x';
256                         g[i] = '\0';
257
258                         i = 0;
259                         if ((mask & S_IROTH) == 0)
260                                 o[i++] = 'r';
261                         if ((mask & S_IWOTH) == 0)
262                                 o[i++] = 'w';
263                         if ((mask & S_IXOTH) == 0)
264                                 o[i++] = 'x';
265                         o[i] = '\0';
266
267                         out1fmt("u=%s,g=%s,o=%s\n", u, g, o);
268                 } else {
269                         out1fmt("%.4o\n", mask);
270                 }
271         } else {
272                 if (isdigit(*ap)) {
273                         mask = 0;
274                         do {
275                                 if (*ap >= '8' || *ap < '0')
276                                         error("Illegal number: %s", argv[1]);
277                                 mask = (mask << 3) + (*ap - '0');
278                         } while (*++ap != '\0');
279                         umask(mask);
280                 } else {
281                         void *set;
282                         if ((set = setmode (ap)) == 0)
283                                 error("Illegal number: %s", ap);
284
285                         mask = getmode (set, ~mask & 0777);
286                         umask(~mask & 0777);
287                         free(set);
288                 }
289         }
290         return 0;
291 }
292
293 /*
294  * ulimit builtin
295  *
296  * This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
297  * Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
298  * ash by J.T. Conklin.
299  *
300  * Public domain.
301  */
302
303 struct limits {
304         const char *name;
305         const char *units;
306         int     cmd;
307         int     factor; /* multiply by to get rlim_{cur,max} values */
308         char    option;
309 };
310
311 static const struct limits limits[] = {
312 #ifdef RLIMIT_CPU
313         { "cpu time",           "seconds",      RLIMIT_CPU,        1, 't' },
314 #endif
315 #ifdef RLIMIT_FSIZE
316         { "file size",          "512-blocks",   RLIMIT_FSIZE,    512, 'f' },
317 #endif
318 #ifdef RLIMIT_DATA
319         { "data seg size",      "kbytes",       RLIMIT_DATA,    1024, 'd' },
320 #endif
321 #ifdef RLIMIT_STACK
322         { "stack size",         "kbytes",       RLIMIT_STACK,   1024, 's' },
323 #endif
324 #ifdef  RLIMIT_CORE
325         { "core file size",     "512-blocks",   RLIMIT_CORE,     512, 'c' },
326 #endif
327 #ifdef RLIMIT_RSS
328         { "max memory size",    "kbytes",       RLIMIT_RSS,     1024, 'm' },
329 #endif
330 #ifdef RLIMIT_MEMLOCK
331         { "locked memory",      "kbytes",       RLIMIT_MEMLOCK, 1024, 'l' },
332 #endif
333 #ifdef RLIMIT_NPROC
334         { "max user processes", (char *)0,      RLIMIT_NPROC,      1, 'u' },
335 #endif
336 #ifdef RLIMIT_NOFILE
337         { "open files",         (char *)0,      RLIMIT_NOFILE,     1, 'n' },
338 #endif
339 #ifdef RLIMIT_VMEM
340         { "virtual mem size",   "kbytes",       RLIMIT_VMEM,    1024, 'v' },
341 #endif
342 #ifdef RLIMIT_SWAP
343         { "swap limit",         "kbytes",       RLIMIT_SWAP,    1024, 'w' },
344 #endif
345 #ifdef RLIMIT_SBSIZE
346         { "sbsize",             "bytes",        RLIMIT_SBSIZE,     1, 'b' },
347 #endif
348 #ifdef RLIMIT_POSIXLOCK
349         { "posixlocks",         (char *)0,      RLIMIT_POSIXLOCK,  1, 'k' },
350 #endif
351         { (char *) 0,           (char *)0,      0,                 0, '\0' }
352 };
353
354 int
355 ulimitcmd(int argc __unused, char **argv __unused)
356 {
357         int     c;
358         quad_t val = 0;
359         enum { SOFT = 0x1, HARD = 0x2 }
360                         how = SOFT | HARD;
361         const struct limits     *l;
362         int             set, all = 0;
363         int             optc, what;
364         struct rlimit   limit;
365
366         what = 'f';
367         while ((optc = nextopt("HSatfdsmcnuvlbk")) != '\0')
368                 switch (optc) {
369                 case 'H':
370                         how = HARD;
371                         break;
372                 case 'S':
373                         how = SOFT;
374                         break;
375                 case 'a':
376                         all = 1;
377                         break;
378                 default:
379                         what = optc;
380                 }
381
382         for (l = limits; l->name && l->option != what; l++)
383                 ;
384         if (!l->name)
385                 error("ulimit: internal error (%c)", what);
386
387         set = *argptr ? 1 : 0;
388         if (set) {
389                 char *p = *argptr;
390
391                 if (all || argptr[1])
392                         error("ulimit: too many arguments");
393                 if (strcmp(p, "unlimited") == 0)
394                         val = RLIM_INFINITY;
395                 else {
396                         val = (quad_t) 0;
397
398                         while ((c = *p++) >= '0' && c <= '9')
399                         {
400                                 val = (val * 10) + (long)(c - '0');
401                                 if (val < (quad_t) 0)
402                                         break;
403                         }
404                         if (c)
405                                 error("ulimit: bad number");
406                         val *= l->factor;
407                 }
408         }
409         if (all) {
410                 for (l = limits; l->name; l++) { 
411                         char optbuf[40];
412                         if (getrlimit(l->cmd, &limit) < 0)
413                                 error("ulimit: can't get limit: %s", strerror(errno));
414                         if (how & SOFT)
415                                 val = limit.rlim_cur;
416                         else if (how & HARD)
417                                 val = limit.rlim_max;
418
419                         if (l->units)
420                                 snprintf(optbuf, sizeof(optbuf),
421                                         "(%s, -%c) ", l->units, l->option);
422                         else
423                                 snprintf(optbuf, sizeof(optbuf),
424                                         "(-%c) ", l->option);
425                         out1fmt("%-18s %18s ", l->name, optbuf);
426                         if (val == RLIM_INFINITY)
427                                 out1fmt("unlimited\n");
428                         else
429                         {
430                                 val /= l->factor;
431                                 out1fmt("%qd\n", (quad_t) val);
432                         }
433                 }
434                 return 0;
435         }
436
437         if (getrlimit(l->cmd, &limit) < 0)
438                 error("ulimit: can't get limit: %s", strerror(errno));
439         if (set) {
440                 if (how & SOFT)
441                         limit.rlim_cur = val;
442                 if (how & HARD)
443                         limit.rlim_max = val;
444                 if (setrlimit(l->cmd, &limit) < 0)
445                         error("ulimit: bad limit: %s", strerror(errno));
446         } else {
447                 if (how & SOFT)
448                         val = limit.rlim_cur;
449                 else if (how & HARD)
450                         val = limit.rlim_max;
451
452                 if (val == RLIM_INFINITY)
453                         out1fmt("unlimited\n");
454                 else
455                 {
456                         val /= l->factor;
457                         out1fmt("%qd\n", (quad_t) val);
458                 }
459         }
460         return 0;
461 }