version.c File Reference

Display version and copyright about NeoMutt. More...

#include "config.h"
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <sys/utsname.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "gui/lib.h"
#include "version.h"
#include "compress/lib.h"
#include "ncrypt/lib.h"
#include <openssl/opensslv.h>
#include <gnutls/gnutls.h>

Include dependency graph for version.c:

Go to the source code of this file.

Data Structures
struct	CompileOptions
	List of built-in capabilities. More...

Functions
const char *	mutt_make_version (void)
	Generate the NeoMutt version string. More...
const char *	store_backend_list (void)
	Get a list of backend names. More...
const char *	store_compress_list (void)
static void	print_compile_options (struct CompileOptions *co, FILE *fp)
	Print a list of enabled/disabled features. More...
static char *	rstrip_in_place (char *s)
	Strip a trailing carriage return. More...
void	print_version (FILE *fp)
	Print system and compile info to a file. More...
void	print_copyright (void)
	Print copyright message. More...
bool	feature_enabled (const char *name)
	Test if a compile-time feature is enabled. More...

Variables
const int	SCREEN_WIDTH = 80
unsigned char	cc_cflags []
unsigned char	configure_options []
static const char *	Copyright
static const char *	Thanks
static const char *	License
static const char *	ReachingUs
static const char *	Notice
static struct CompileOptions	comp_opts_default []
static struct CompileOptions	comp_opts []

Detailed Description

Display version and copyright about NeoMutt.

Authors

• Michael R. Elkins
• Thomas Roessler
• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file version.c.

Function Documentation

mutt_make_version()

const char* mutt_make_version

(

void

)

Generate the NeoMutt version string.

Return values

ptr	Version string

Note

This returns a pointer to a static buffer

Definition at line 1460 of file muttlib.c.

{
  static char vstring[256];
  snprintf(vstring, sizeof(vstring), "NeoMutt %s%s", PACKAGE_VERSION, GitVer);
  return vstring;
}

Here is the caller graph for this function:

store_backend_list()

const char* store_backend_list

(

void

)

Get a list of backend names.

Return values

ptr	Comma-space-separated list of names

The caller should free the string.

Definition at line 84 of file store.c.

{
  char tmp[256] = { 0 };
  const struct StoreOps **ops = store_ops;
  size_t len = 0;

  for (; *ops; ops++)
  {
    if (len != 0)
    {
      len += snprintf(tmp + len, sizeof(tmp) - len, ", ");
    }
    len += snprintf(tmp + len, sizeof(tmp) - len, "%s", (*ops)->name);
  }

  return mutt_str_dup(tmp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

store_compress_list()

const char* store_compress_list

(

void

)

print_compile_options()

static void print_compile_options ( struct CompileOptions *  co, FILE *  fp  )

static

Print a list of enabled/disabled features.

Parameters

co	Array of compile options
fp	file to write to

Two lists are generated and passed to this function:

One list which just uses the configure state of each feature. One list which just uses feature which are set to on directly in NeoMutt.

The output is of the form: "+enabled_feature -disabled_feature" and is wrapped to SCREEN_WIDTH characters.

Definition at line 351 of file version.c.

{
  if (!co || !fp)
    return;

  size_t used = 2;
  bool tty = isatty(fileno(fp));

  fprintf(fp, "  ");
  for (int i = 0; co[i].name; i++)
  {
    const size_t len = strlen(co[i].name) + 2; /* +/- and a space */
    if ((used + len) > SCREEN_WIDTH)
    {
      used = 2;
      fprintf(fp, "\n  ");
    }
    used += len;
    const char *fmt = "?%s ";
    switch (co[i].enabled)
    {
      case 0: // Disabled
        if (tty)
          fmt = "\033[1;31m-%s\033[0m "; // Escape, red
        else
          fmt = "-%s ";
        break;
      case 1: // Enabled
        if (tty)
          fmt = "\033[1;32m+%s\033[0m "; // Escape, green
        else
          fmt = "+%s ";
        break;
      case 2: // Devel only
        if (tty)
          fmt = "\033[1;36m!%s\033[0m "; // Escape, cyan
        else
          fmt = "!%s ";
        break;
    }
    fprintf(fp, fmt, co[i].name);
  }
  fprintf(fp, "\n");
}

Here is the caller graph for this function:

rstrip_in_place()

static char* rstrip_in_place ( char *  s )

static

Strip a trailing carriage return.

Parameters

s	String to be modified

Return values

ptr	The modified string

The string has its last carriage return set to NUL.

Definition at line 403 of file version.c.

{
  if (!s)
    return NULL;

  char *p = &s[strlen(s)];
  if (p == s)
    return s;
  p--;
  while ((p >= s) && ((*p == '\n') || (*p == '\r')))
    *p-- = '\0';
  return s;
}

Here is the caller graph for this function:

print_version()

void print_version

(

FILE *

fp

)

Print system and compile info to a file.

Parameters

fp	- file to print to

Print information about the current system NeoMutt is running on. Also print a list of all the compile-time information.

Definition at line 424 of file version.c.

{
  if (!fp)
    return;

  struct utsname uts;
  bool tty = isatty(fileno(fp));
  const char *fmt = "%s\n";

  if (tty)
    fmt = "\033[1;36m%s\033[0m\n"; // Escape, cyan

  fprintf(fp, fmt, mutt_make_version());
  fprintf(fp, "%s\n", _(Notice));

  uname(&uts);

#ifdef SCO
  fprintf(fp, "System: SCO %s", uts.release);
#else
  fprintf(fp, "System: %s %s", uts.sysname, uts.release);
#endif

  fprintf(fp, " (%s)", uts.machine);

#ifdef NCURSES_VERSION
  fprintf(fp, "\nncurses: %s (compiled with %s.%d)", curses_version(),
          NCURSES_VERSION, NCURSES_VERSION_PATCH);
#elif defined(USE_SLANG_CURSES)
  fprintf(fp, "\nslang: %s", SLANG_VERSION_STRING);
#endif

#ifdef _LIBICONV_VERSION
  fprintf(fp, "\nlibiconv: %d.%d", _LIBICONV_VERSION >> 8, _LIBICONV_VERSION & 0xff);
#endif

#ifdef HAVE_LIBIDN
  fprintf(fp, "\n%s", mutt_idna_print_version());
#endif

#ifdef CRYPT_BACKEND_GPGME
  fprintf(fp, "\nGPGME: %s", mutt_gpgme_print_version());
#endif

#ifdef USE_SSL_OPENSSL
#ifdef LIBRESSL_VERSION_TEXT
  fprintf(fp, "\nLibreSSL: %s", LIBRESSL_VERSION_TEXT);
#endif
#ifdef OPENSSL_VERSION_TEXT
  fprintf(fp, "\nOpenSSL: %s", OPENSSL_VERSION_TEXT);
#endif
#endif

#ifdef USE_SSL_GNUTLS
  fprintf(fp, "\nGnuTLS: %s", GNUTLS_VERSION);
#endif

#ifdef HAVE_NOTMUCH
  fprintf(fp, "\nlibnotmuch: %d.%d.%d", LIBNOTMUCH_MAJOR_VERSION,
          LIBNOTMUCH_MINOR_VERSION, LIBNOTMUCH_MICRO_VERSION);
#endif

#ifdef HAVE_PCRE2
  {
    char version[24];
    pcre2_config(PCRE2_CONFIG_VERSION, version);
    fprintf(fp, "\nPCRE2: %s", version);
  }
#endif

#ifdef USE_HCACHE
  const char *backends = store_backend_list();
  fprintf(fp, "\nstorage: %s", backends);
  FREE(&backends);
#ifdef USE_HCACHE_COMPRESSION
  backends = compress_list();
  fprintf(fp, "\ncompression: %s", backends);
  FREE(&backends);
#endif
#endif

  rstrip_in_place((char *) configure_options);
  fprintf(fp, "\n\nConfigure options: %s\n", (char *) configure_options);

  rstrip_in_place((char *) cc_cflags);
  fprintf(fp, "\nCompilation CFLAGS: %s\n", (char *) cc_cflags);

  fprintf(fp, "\n%s\n", _("Default options:"));
  print_compile_options(comp_opts_default, fp);

  fprintf(fp, "\n%s\n", _("Compile options:"));
  print_compile_options(comp_opts, fp);

#ifdef DOMAIN
  fprintf(fp, "DOMAIN=\"%s\"\n", DOMAIN);
#endif
#ifdef ISPELL
  fprintf(fp, "ISPELL=\"%s\"\n", ISPELL);
#endif
  fprintf(fp, "MAILPATH=\"%s\"\n", MAILPATH);
#ifdef MIXMASTER
  fprintf(fp, "MIXMASTER=\"%s\"\n", MIXMASTER);
#endif
  fprintf(fp, "PKGDATADIR=\"%s\"\n", PKGDATADIR);
  fprintf(fp, "SENDMAIL=\"%s\"\n", SENDMAIL);
  fprintf(fp, "SYSCONFDIR=\"%s\"\n", SYSCONFDIR);

  fprintf(fp, "\n");
  fputs(_(ReachingUs), fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_copyright()

void print_copyright

(

void

)

Print copyright message.

Print the authors' copyright messages, the GPL license and some contact information for the NeoMutt project.

Definition at line 541 of file version.c.

{
  puts(mutt_make_version());
  puts(Copyright);
  puts(_(Thanks));
  puts(_(License));
  puts(_(ReachingUs));
}

Here is the call graph for this function:

Here is the caller graph for this function:

feature_enabled()

bool feature_enabled

(

const char *

name

)

Test if a compile-time feature is enabled.

Parameters

name	Compile-time symbol of the feature

Return values

true	Feature enabled
false	Feature not enabled, or not compiled in

Many of the larger features of neomutt can be disabled at compile time. They define a symbol and use ifdef's around their code. The symbols are mirrored in "CompileOptions comp_opts[]" in this file.

This function checks if one of these symbols is present in the code.

These symbols are also seen in the output of "neomutt -v".

Definition at line 565 of file version.c.

{
  if (!name)
    return false;
  for (int i = 0; comp_opts_default[i].name; i++)
  {
    if (mutt_str_equal(name, comp_opts_default[i].name))
    {
      return true;
    }
  }
  for (int i = 0; comp_opts[i].name; i++)
  {
    if (mutt_str_equal(name, comp_opts[i].name))
    {
      return comp_opts[i].enabled;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

SCREEN_WIDTH

const int SCREEN_WIDTH = 80

Definition at line 67 of file version.c.

cc_cflags

unsigned char cc_cflags[]

configure_options

unsigned char configure_options[]

Copyright

const char* Copyright

static

Initial value:

=
    "Copyright (C) 1996-2020 Michael R. Elkins <me@mutt.org>\n"
    "Copyright (C) 1996-2002 Brandon Long <blong@fiction.net>\n"
    "Copyright (C) 1997-2009 Thomas Roessler <roessler@does-not-exist.org>\n"
    "Copyright (C) 1998-2005 Werner Koch <wk@isil.d.shuttle.de>\n"
    "Copyright (C) 1999-2017 Brendan Cully <brendan@kublai.com>\n"
    "Copyright (C) 1999-2002 Tommi Komulainen <Tommi.Komulainen@iki.fi>\n"
    "Copyright (C) 2000-2004 Edmund Grimley Evans <edmundo@rano.org>\n"
    "Copyright (C) 2006-2009 Rocco Rutte <pdmef@gmx.net>\n"
    "Copyright (C) 2014-2020 Kevin J. McCarthy <kevin@8t8.us>\n"
    "Copyright (C) 2015-2020 Richard Russon <rich@flatcap.org>\n"

Definition at line 72 of file version.c.

Thanks

const char* Thanks

static

Initial value:

=
    N_("Many others not mentioned here contributed code, fixes,\n"
       "and suggestions.\n")

Definition at line 84 of file version.c.

License

const char* License

static

Initial value:

= N_(
    "    This program is free software; you can redistribute it and/or modify\n"
    "    it under the terms of the GNU General Public License as published by\n"
    "    the Free Software Foundation; either version 2 of the License, or\n"
    "    (at your option) any later version.\n"
    "\n"
    "    This program is distributed in the hope that it will be useful,\n"
    "    but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
    "    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
    "    GNU General Public License for more details.\n"
    "\n"
    "    You should have received a copy of the GNU General Public License\n"
    "    along with this program; if not, write to the Free Software\n"
    "    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  "
    "02110-1301, USA.\n")

Definition at line 88 of file version.c.

ReachingUs

const char* ReachingUs

static

Initial value:

=
    N_("To learn more about NeoMutt, visit: https://neomutt.org\n"
       "If you find a bug in NeoMutt, please raise an issue at:\n"
       "    https://github.com/neomutt/neomutt/issues\n"
       "or send an email to: <neomutt-devel@neomutt.org>\n")

Definition at line 104 of file version.c.

Notice

const char* Notice

static

Initial value:

=
    N_("Copyright (C) 1996-2020 Michael R. Elkins and others.\n"
       "NeoMutt comes with ABSOLUTELY NO WARRANTY; for details type 'neomutt -vv'.\n"
       "NeoMutt is free software, and you are welcome to redistribute it\n"
       "under certain conditions; type 'neomutt -vv' for details.\n")

Definition at line 111 of file version.c.

comp_opts_default

struct CompileOptions comp_opts_default[]

static

Definition at line 129 of file version.c.

comp_opts

struct CompileOptions comp_opts[]

static

Definition at line 163 of file version.c.