usr.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  * $FreeBSD: head/bin/kenv/kenv.c 250666 2013-05-15 18:38:28Z delphij $
  26  */
  27
  28 #include <sys/types.h>
  29 #include <sys/sysctl.h>
  30 #include <err.h>
  31 #include <kenv.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36
  37 static void     usage(void);
  38 static int      kdumpenv(void);
  39 static int      kgetenv(const char *);
  40 static int      ksetenv(const char *, char *);
  41 static int      kunsetenv(const char *);
  42
  43 static int hflag = 0;
  44 static int Nflag = 0;
  45 static int qflag = 0;
  46 static int uflag = 0;
  47 static int vflag = 0;
  48
  49 static void
  50 usage(void)
  51 {
  52         (void)fprintf(stderr, "%s\n%s\n%s\n",
  53             "usage: kenv [-hNq]",
  54             "       kenv [-qv] variable[=value]",
  55             "       kenv [-q] -u variable");
  56         exit(1);
  57 }
  58
  59 int
  60 main(int argc, char **argv)
  61 {
  62         char *env, *eq, *val;
  63         int ch, error;
  64
  65         error = 0;
  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, *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 = malloc(buflen + 1);
 139                 if (buf == NULL)
 140                         return (-1);
 141                 memset(buf, 0, buflen + 1);     /* Be defensive */
 142                 envlen = kenv(KENV_DUMP, NULL, buf, buflen);
 143                 if (envlen < 0) {
 144                         free(buf);
 145                         return (-1);
 146                 }
 147                 if (envlen > buflen)
 148                         free(buf);
 149                 else
 150                         break;
 151         }
 152
 153         for (; *buf != '\0'; buf += strlen(buf) + 1) {
 154                 if (hflag) {
 155                         if (strncmp(buf, "hint.", 5) != 0)
 156                                 continue;
 157                 }
 158                 cp = strchr(buf, '=');
 159                 if (cp == NULL)
 160                         continue;
 161                 *cp++ = '\0';
 162                 if (Nflag)
 163                         printf("%s\n", buf);
 164                 else
 165                         printf("%s=\"%s\"\n", buf, cp);
 166                 buf = cp;
 167         }
 168         return (0);
 169 }
 170
 171 static int
 172 kgetenv(const char *env)
 173 {
 174         char buf[1024];
 175         int ret;
 176
 177         ret = kenv(KENV_GET, env, buf, sizeof(buf));
 178         if (ret == -1)
 179                 return (ret);
 180         if (vflag)
 181                 printf("%s=\"%s\"\n", env, buf);
 182         else
 183                 printf("%s\n", buf);
 184         return (0);
 185 }
 186
 187 static int
 188 ksetenv(const char *env, char *val)
 189 {
 190         int ret;
 191
 192         ret = kenv(KENV_SET, env, val, strlen(val)+1);
 193         if (ret == 0)
 194                 printf("%s=\"%s\"\n", env, val);
 195         return (ret);
 196 }
 197
 198 static int
 199 kunsetenv(const char *env)
 200 {
 201         int ret;
 202
 203         ret = kenv(KENV_UNSET, env, NULL, 0);
 204         return (ret);
 205 }