src/uname.c

   1 /* uname -- print system information
   2
   3    Copyright (C) 1989, 1992, 1993, 1996, 1997, 1999, 2000, 2001, 2002,
   4    2003, 2004, 2005 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software Foundation,
  18    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 /* Written by David MacKenzie <djm@gnu.ai.mit.edu> */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include <sys/utsname.h>
  26 #include <getopt.h>
  27
  28 #if HAVE_SYSINFO && HAVE_SYS_SYSTEMINFO_H
  29 # include <sys/systeminfo.h>
  30 #endif
  31
  32 #if HAVE_SYS_SYSCTL_H
  33 # if HAVE_SYS_PARAM_H
  34 #  include <sys/param.h> /* needed for OpenBSD 3.0 */
  35 # endif
  36 # include <sys/sysctl.h>
  37 # ifdef HW_MODEL
  38 #  ifdef HW_MACHINE_ARCH
  39 /* E.g., FreeBSD 4.5, NetBSD 1.5.2 */
  40 #   define UNAME_HARDWARE_PLATFORM HW_MODEL
  41 #   define UNAME_PROCESSOR HW_MACHINE_ARCH
  42 #  else
  43 /* E.g., OpenBSD 3.0 */
  44 #   define UNAME_PROCESSOR HW_MODEL
  45 #  endif
  46 # endif
  47 #endif
  48
  49 #ifdef __APPLE__
  50 # include <mach/machine.h>
  51 # include <mach-o/arch.h>
  52 #endif
  53
  54 #include "system.h"
  55 #include "error.h"
  56 #include "quote.h"
  57
  58 /* The official name of this program (e.g., no `g' prefix).  */
  59 #define PROGRAM_NAME "uname"
  60
  61 #define AUTHORS "David MacKenzie"
  62
  63 /* Values that are bitwise or'd into `toprint'. */
  64 /* Kernel name. */
  65 #define PRINT_KERNEL_NAME 1
  66
  67 /* Node name on a communications network. */
  68 #define PRINT_NODENAME 2
  69
  70 /* Kernel release. */
  71 #define PRINT_KERNEL_RELEASE 4
  72
  73 /* Kernel version. */
  74 #define PRINT_KERNEL_VERSION 8
  75
  76 /* Machine hardware name. */
  77 #define PRINT_MACHINE 16
  78
  79 /* Processor type. */
  80 #define PRINT_PROCESSOR 32
  81
  82 /* Hardware platform.  */
  83 #define PRINT_HARDWARE_PLATFORM 64
  84
  85 /* Operating system.  */
  86 #define PRINT_OPERATING_SYSTEM 128
  87
  88 /* The name this program was run with, for error messages. */
  89 char *program_name;
  90
  91 static struct option const long_options[] =
  92 {
  93   {"all", no_argument, NULL, 'a'},
  94   {"kernel-name", no_argument, NULL, 's'},
  95   {"sysname", no_argument, NULL, 's'},  /* Obsolescent.  */
  96   {"nodename", no_argument, NULL, 'n'},
  97   {"kernel-release", no_argument, NULL, 'r'},
  98   {"release", no_argument, NULL, 'r'},  /* Obsolescent.  */
  99   {"kernel-version", no_argument, NULL, 'v'},
 100   {"machine", no_argument, NULL, 'm'},
 101   {"processor", no_argument, NULL, 'p'},
 102   {"hardware-platform", no_argument, NULL, 'i'},
 103   {"operating-system", no_argument, NULL, 'o'},
 104   {GETOPT_HELP_OPTION_DECL},
 105   {GETOPT_VERSION_OPTION_DECL},
 106   {NULL, 0, NULL, 0}
 107 };
 108
 109 void
 110 usage (int status)
 111 {
 112   if (status != EXIT_SUCCESS)
 113     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 114              program_name);
 115   else
 116     {
 117       printf (_("Usage: %s [OPTION]...\n"), program_name);
 118       fputs (_("\
 119 Print certain system information.  With no OPTION, same as -s.\n\
 120 \n\
 121   -a, --all                print all information, in the following order,\n\
 122                              except omit -p and -i if unknown:\n\
 123   -s, --kernel-name        print the kernel name\n\
 124   -n, --nodename           print the network node hostname\n\
 125   -r, --kernel-release     print the kernel release\n\
 126 "), stdout);
 127       fputs (_("\
 128   -v, --kernel-version     print the kernel version\n\
 129   -m, --machine            print the machine hardware name\n\
 130   -p, --processor          print the processor type or \"unknown\"\n\
 131   -i, --hardware-platform  print the hardware platform or \"unknown\"\n\
 132   -o, --operating-system   print the operating system\n\
 133 "), stdout);
 134       fputs (HELP_OPTION_DESCRIPTION, stdout);
 135       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 136       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 137     }
 138   exit (status);
 139 }
 140
 141 /* Print ELEMENT, preceded by a space if something has already been
 142    printed.  */
 143
 144 static void
 145 print_element (char const *element)
 146 {
 147   static bool printed;
 148   if (printed)
 149     putchar (' ');
 150   printed = true;
 151   fputs (element, stdout);
 152 }
 153
 154 int
 155 main (int argc, char **argv)
 156 {
 157   int c;
 158   static char const unknown[] = "unknown";
 159
 160   /* Mask indicating which elements to print. */
 161   unsigned int toprint = 0;
 162
 163   initialize_main (&argc, &argv);
 164   program_name = argv[0];
 165   setlocale (LC_ALL, "");
 166   bindtextdomain (PACKAGE, LOCALEDIR);
 167   textdomain (PACKAGE);
 168
 169   atexit (close_stdout);
 170
 171   while ((c = getopt_long (argc, argv, "asnrvmpio", long_options, NULL)) != -1)
 172     {
 173       switch (c)
 174         {
 175         case 'a':
 176           toprint = UINT_MAX;
 177           break;
 178
 179         case 's':
 180           toprint |= PRINT_KERNEL_NAME;
 181           break;
 182
 183         case 'n':
 184           toprint |= PRINT_NODENAME;
 185           break;
 186
 187         case 'r':
 188           toprint |= PRINT_KERNEL_RELEASE;
 189           break;
 190
 191         case 'v':
 192           toprint |= PRINT_KERNEL_VERSION;
 193           break;
 194
 195         case 'm':
 196           toprint |= PRINT_MACHINE;
 197           break;
 198
 199         case 'p':
 200           toprint |= PRINT_PROCESSOR;
 201           break;
 202
 203         case 'i':
 204           toprint |= PRINT_HARDWARE_PLATFORM;
 205           break;
 206
 207         case 'o':
 208           toprint |= PRINT_OPERATING_SYSTEM;
 209           break;
 210
 211         case_GETOPT_HELP_CHAR;
 212
 213         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 214
 215         default:
 216           usage (EXIT_FAILURE);
 217         }
 218     }
 219
 220   if (argc != optind)
 221     {
 222       error (0, 0, _("extra operand %s"), quote (argv[optind]));
 223       usage (EXIT_FAILURE);
 224     }
 225
 226   if (toprint == 0)
 227     toprint = PRINT_KERNEL_NAME;
 228
 229   if (toprint
 230        & (PRINT_KERNEL_NAME | PRINT_NODENAME | PRINT_KERNEL_RELEASE
 231           | PRINT_KERNEL_VERSION | PRINT_MACHINE))
 232     {
 233       struct utsname name;
 234
 235       if (uname (&name) == -1)
 236         error (EXIT_FAILURE, errno, _("cannot get system name"));
 237
 238       if (toprint & PRINT_KERNEL_NAME)
 239         print_element (name.sysname);
 240       if (toprint & PRINT_NODENAME)
 241         print_element (name.nodename);
 242       if (toprint & PRINT_KERNEL_RELEASE)
 243         print_element (name.release);
 244       if (toprint & PRINT_KERNEL_VERSION)
 245         print_element (name.version);
 246       if (toprint & PRINT_MACHINE)
 247         print_element (name.machine);
 248     }
 249
 250   if (toprint & PRINT_PROCESSOR)
 251     {
 252       char const *element = unknown;
 253 #if HAVE_SYSINFO && defined SI_ARCHITECTURE
 254       {
 255         static char processor[257];
 256         if (0 <= sysinfo (SI_ARCHITECTURE, processor, sizeof processor))
 257           element = processor;
 258       }
 259 #endif
 260 #ifdef UNAME_PROCESSOR
 261       if (element == unknown)
 262         {
 263           static char processor[257];
 264           size_t s = sizeof processor;
 265           static int mib[] = { CTL_HW, UNAME_PROCESSOR };
 266           if (sysctl (mib, 2, processor, &s, 0, 0) >= 0)
 267             element = processor;
 268
 269 # ifdef __APPLE__
 270           /* This kludge works around a bug in Mac OS X.  */
 271           if (element == unknown)
 272             {
 273               cpu_type_t cputype;
 274               size_t s = sizeof cputype;
 275               NXArchInfo const *ai;
 276               if (sysctlbyname ("hw.cputype", &cputype, &s, NULL, 0) == 0
 277                   && (ai = NXGetArchInfoFromCpuType (cputype,
 278                                                      CPU_SUBTYPE_MULTIPLE))
 279                   != NULL)
 280                 element = ai->name;
 281
 282               /* Hack "safely" around the ppc vs. powerpc return value. */
 283               if (cputype == CPU_TYPE_POWERPC
 284                   && strncmp (element, "ppc", 3) == 0)
 285                 element = "powerpc";
 286             }
 287 # endif
 288         }
 289 #endif
 290       if (! (toprint == UINT_MAX && element == unknown))
 291         print_element (element);
 292     }
 293
 294   if (toprint & PRINT_HARDWARE_PLATFORM)
 295     {
 296       char const *element = unknown;
 297 #if HAVE_SYSINFO && defined SI_PLATFORM
 298       {
 299         static char hardware_platform[257];
 300         if (0 <= sysinfo (SI_PLATFORM,
 301                           hardware_platform, sizeof hardware_platform))
 302           element = hardware_platform;
 303       }
 304 #endif
 305 #ifdef UNAME_HARDWARE_PLATFORM
 306       if (element == unknown)
 307         {
 308           static char hardware_platform[257];
 309           size_t s = sizeof hardware_platform;
 310           static int mib[] = { CTL_HW, UNAME_HARDWARE_PLATFORM };
 311           if (sysctl (mib, 2, hardware_platform, &s, 0, 0) >= 0)
 312             element = hardware_platform;
 313         }
 314 #endif
 315       if (! (toprint == UINT_MAX && element == unknown))
 316         print_element (element);
 317     }
 318
 319   if (toprint & PRINT_OPERATING_SYSTEM)
 320     print_element (HOST_OPERATING_SYSTEM);
 321
 322   putchar ('\n');
 323
 324   exit (EXIT_SUCCESS);
 325 }