bin/kenv/kenv.c

   1 /*-
   2  * Copyright (c) 2000  Peter Wemm <peter@freebsd.org>
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 #include <sys/types.h>
  30 #include <sys/sysctl.h>
  31 #include <err.h>
  32 #include <kenv.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include <unistd.h>
  37
  38 static void     usage(void);
  39 static int      kdumpenv(void);
  40 static int      kgetenv(const char *);
  41 static int      ksetenv(const char *, char *);
  42 static int      kunsetenv(const char *);
  43
  44 static int hflag = 0;
  45 static int Nflag = 0;
  46 static int qflag = 0;
  47 static int uflag = 0;
  48 static int vflag = 0;
  49
  50 static void
  51 usage(void)
  52 {
  53         (void)fprintf(stderr, "%s\n%s\n%s\n",
  54             "usage: kenv [-hNq]",
  55             "       kenv [-qv] variable[=value]",
  56             "       kenv [-q] -u variable");
  57         exit(1);
  58 }
  59
  60 int
  61 main(int argc, char **argv)
  62 {
  63         char *env, *eq, *val;
  64         int ch, error;
  65
  66         val = NULL;
  67         env = NULL;
  68         while ((ch = getopt(argc, argv, "hNquv")) != -1) {
  69                 switch (ch) {
  70                 case 'h':
  71                         hflag++;
  72                         break;
  73                 case 'N':
  74                         Nflag++;
  75                         break;
  76                 case 'q':
  77                         qflag++;
  78                         break;
  79                 case 'u':
  80                         uflag++;
  81                         break;
  82                 case 'v':
  83                         vflag++;
  84                         break;
  85                 default:
  86                         usage();
  87                 }
  88         }
  89         argc -= optind;
  90         argv += optind;
  91         if (argc > 0) {
  92                 env = argv[0];
  93                 eq = strchr(env, '=');
  94                 if (eq != NULL) {
  95                         *eq++ = '\0';
  96                         val = eq;
  97                 }
  98                 argv++;
  99                 argc--;
 100         }
 101         if ((hflag || Nflag) && env != NULL)
 102                 usage();
 103         if (argc > 0 || ((uflag || vflag) && env == NULL))
 104                 usage();
 105         if (env == NULL) {
 106                 error = kdumpenv();
 107                 if (error && !qflag)
 108                         warn("kdumpenv");
 109         } else if (val == NULL) {
 110                 if (uflag) {
 111                         error = kunsetenv(env);
 112                         if (error && !qflag)
 113                                 warnx("unable to unset %s", env);
 114                 } else {
 115                         error = kgetenv(env);
 116                         if (error && !qflag)
 117                                 warnx("unable to get %s", env);
 118                 }
 119         } else {
 120                 error = ksetenv(env, val);
 121                 if (error && !qflag)
 122                         warnx("unable to set %s to %s", env, val);
 123         }
 124         return (error);
 125 }
 126
 127 static int
 128 kdumpenv(void)
 129 {
 130         char *buf, *bp, *cp;
 131         int buflen, envlen;
 132
 133         envlen = kenv(KENV_DUMP, NULL, NULL, 0);
 134         if (envlen < 0)
 135                 return (-1);
 136         for (;;) {
 137                 buflen = envlen * 120 / 100;
 138                 buf = calloc(1, buflen + 1);
 139                 if (buf == NULL)
 140                         return (-1);
 141                 envlen = kenv(KENV_DUMP, NULL, buf, buflen);
 142                 if (envlen < 0) {
 143                         free(buf);
 144                         return (-1);
 145                 }
 146                 if (envlen > buflen)
 147                         free(buf);
 148                 else
 149                         break;
 150         }
 151
 152         for (bp = buf; *bp != '\0'; bp += strlen(bp) + 1) {
 153                 if (hflag) {
 154                         if (strncmp(bp, "hint.", 5) != 0)
 155                                 continue;
 156                 }
 157                 cp = strchr(bp, '=');
 158                 if (cp == NULL)
 159                         continue;
 160                 *cp++ = '\0';
 161                 if (Nflag)
 162                         printf("%s\n", bp);
 163                 else
 164                         printf("%s=\"%s\"\n", bp, cp);
 165                 bp = cp;
 166         }
 167
 168         free(buf);
 169         return (0);
 170 }
 171
 172 static int
 173 kgetenv(const char *env)
 174 {
 175         char buf[1024];
 176         int ret;
 177
 178         ret = kenv(KENV_GET, env, buf, sizeof(buf));
 179         if (ret == -1)
 180                 return (ret);
 181         if (vflag)
 182                 printf("%s=\"%s\"\n", env, buf);
 183         else
 184                 printf("%s\n", buf);
 185         return (0);
 186 }
 187
 188 static int
 189 ksetenv(const char *env, char *val)
 190 {
 191         int ret;
 192
 193         ret = kenv(KENV_SET, env, val, strlen(val) + 1);
 194         if (ret == 0)
 195                 printf("%s=\"%s\"\n", env, val);
 196         return (ret);
 197 }
 198
 199 static int
 200 kunsetenv(const char *env)
 201 {
 202         int ret;
 203
 204         ret = kenv(KENV_UNSET, env, NULL, 0);
 205         return (ret);
 206 }