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 "address/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.
const char *	store_backend_list (void)
	Get a list of backend names.
const char *	store_compress_list (void)
static void	print_compile_options (const struct CompileOptions *co, FILE *fp)
	Print a list of enabled/disabled features.
static char *	rstrip_in_place (char *s)
	Strip a trailing carriage return.
bool	print_version (FILE *fp)
	Print system and compile info to a file.
bool	print_copyright (void)
	Print copyright message.
bool	feature_enabled (const char *name)
	Test if a compile-time feature is enabled.

Variables
static const int	SCREEN_WIDTH = 80
	CLI: Width to wrap version info.
unsigned char	cc_cflags []
unsigned char	configure_options []
static const char *	Copyright
	CLI Version: Authors' copyrights.
static const char *	Thanks
	CLI Version: Thanks.
static const char *	License
	CLI Version: License.
static const char *	ReachingUs
	CLI Version: How to reach the NeoMutt Team.
static const char *	Notice
	CLI Version: Warranty notice.
static const struct CompileOptions	CompOpts []
	Compile options strings for neomutt -v output.
static const struct CompileOptions	DebugOpts []
	Debug options strings for neomutt -v output.

Detailed Description

Display version and copyright about NeoMutt.

Authors

• Pietro Cerutti
• 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 893 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 **store_ops = StoreOps;
  size_t len = 0;
 
  for (; *store_ops; store_ops++)
  {
    if (len != 0)
    {
      len += snprintf(tmp + len, sizeof(tmp) - len, ", ");
    }
    len += snprintf(tmp + len, sizeof(tmp) - len, "%s", (*store_ops)->name);
  }
 
  return mutt_str_dup(tmp);
}

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 ( const 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 319 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 371 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()

bool print_version

(

FILE *

fp

)

Print system and compile info to a file.

Parameters

fp	File to print to

Return values

true	Text displayed

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

Definition at line 393 of file version.c.

{
  if (!fp)
    return false;
 
  struct utsname uts = { 0 };
  bool tty = isatty(fileno(fp));
 
  const char *col_cyan = "";
  const char *col_bold = "";
  const char *col_end = "";
 
  if (tty)
  {
    col_cyan = "\033[1;36m"; // Escape, cyan
    col_bold = "\033[1m";    // Escape, bold
    col_end = "\033[0m";     // Escape, end
  }
 
  fprintf(fp, "%s%s%s\n", col_cyan, mutt_make_version(), col_end);
  fprintf(fp, "%s\n", _(Notice));
 
  uname(&uts);
 
  fprintf(fp, "%sSystem:%s ", col_bold, col_end);
#ifdef SCO
  fprintf(fp, "SCO %s", uts.release);
#else
  fprintf(fp, "%s %s", uts.sysname, uts.release);
#endif
 
  fprintf(fp, " (%s)", uts.machine);
 
  fprintf(fp, "\n%sncurses:%s %s", col_bold, col_end, curses_version());
#ifdef NCURSES_VERSION
  fprintf(fp, " (compiled with %s.%d)", NCURSES_VERSION, NCURSES_VERSION_PATCH);
#endif
 
#ifdef _LIBICONV_VERSION
  fprintf(fp, "\n%slibiconv:%s %d.%d", col_bold, col_end,
          _LIBICONV_VERSION >> 8, _LIBICONV_VERSION & 0xff);
#endif
 
#ifdef HAVE_LIBIDN
  fprintf(fp, "\n%slibidn2:%s %s", col_bold, col_end, mutt_idna_print_version());
#endif
 
#ifdef CRYPT_BACKEND_GPGME
  fprintf(fp, "\n%sGPGME:%s %s", col_bold, col_end, mutt_gpgme_print_version());
#endif
 
#ifdef USE_SSL_OPENSSL
#ifdef LIBRESSL_VERSION_TEXT
  fprintf(fp, "\n%sLibreSSL:%s %s", col_bold, col_end, LIBRESSL_VERSION_TEXT);
#endif
#ifdef OPENSSL_VERSION_TEXT
  fprintf(fp, "\n%sOpenSSL:%s %s", col_bold, col_end, OPENSSL_VERSION_TEXT);
#endif
#endif
 
#ifdef USE_SSL_GNUTLS
  fprintf(fp, "\n%sGnuTLS:%s %s", col_bold, col_end, GNUTLS_VERSION);
#endif
 
#ifdef HAVE_NOTMUCH
  fprintf(fp, "\n%slibnotmuch:%s %d.%d.%d", col_bold, col_end, LIBNOTMUCH_MAJOR_VERSION,
          LIBNOTMUCH_MINOR_VERSION, LIBNOTMUCH_MICRO_VERSION);
#endif
 
#ifdef HAVE_PCRE2
  {
    char version[24] = { 0 };
    pcre2_config(PCRE2_CONFIG_VERSION, version);
    fprintf(fp, "\n%sPCRE2:%s %s", col_bold, col_end, version);
  }
#endif
 
#ifdef USE_HCACHE
  const char *backends = store_backend_list();
  fprintf(fp, "\n%sstorage:%s %s", col_bold, col_end, backends);
  FREE(&backends);
#ifdef USE_HCACHE_COMPRESSION
  backends = compress_list();
  fprintf(fp, "\n%scompression:%s %s", col_bold, col_end, backends);
  FREE(&backends);
#endif
#endif
 
  rstrip_in_place((char *) configure_options);
  fprintf(fp, "\n\n%sConfigure options:%s %s\n", col_bold, col_end, (char *) configure_options);
 
  rstrip_in_place((char *) cc_cflags);
  fprintf(fp, "\n%sCompilation CFLAGS:%s %s\n", col_bold, col_end, (char *) cc_cflags);
 
  fprintf(fp, "\n%s%s%s\n", col_bold, _("Compile options:"), col_end);
  print_compile_options(CompOpts, fp);
 
  if (DebugOpts[0].name)
  {
    fprintf(fp, "\n%s%s%s\n", col_bold, _("Devel options:"), col_end);
    print_compile_options(DebugOpts, fp);
  }
 
  fprintf(fp, "\n");
#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);
 
  fflush(fp);
  return !ferror(fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

print_copyright()

bool print_copyright

(

void

)

Print copyright message.

Return values

true	Text displayed

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

Definition at line 525 of file version.c.

{
  puts(mutt_make_version());
  puts(Copyright);
  puts(_(Thanks));
  puts(_(License));
  puts(_(ReachingUs));
 
  fflush(stdout);
  return !ferror(stdout);
}

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 CompOpts[]" 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 552 of file version.c.

{
  if (!name)
    return false;
  for (int i = 0; CompOpts[i].name; i++)
  {
    if (mutt_str_equal(name, CompOpts[i].name))
    {
      return CompOpts[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

static

CLI: Width to wrap version info.

Definition at line 65 of file version.c.

cc_cflags

unsigned char cc_cflags[]

extern

configure_options

unsigned char configure_options[]

extern

Copyright

const char* Copyright

static

Initial value:

=
    "Copyright (C) 2015-2024 Richard Russon <rich@flatcap.org>\n"
    "Copyright (C) 2016-2023 Pietro Cerutti <gahr@gahr.ch>\n"
    "Copyright (C) 2017-2019 Mehdi Abaakouk <sileht@sileht.net>\n"
    "Copyright (C) 2018-2020 Federico Kircheis <federico.kircheis@gmail.com>\n"
    "Copyright (C) 2017-2022 Austin Ray <austin@austinray.io>\n"
    "Copyright (C) 2023-2024 Dennis Schön <mail@dennis-schoen.de>\n"
    "Copyright (C) 2016-2017 Damien Riegel <damien.riegel@gmail.com>\n"
    "Copyright (C) 2023      Rayford Shireman\n"
    "Copyright (C) 2021-2023 David Purton <dcpurton@marshwiggle.net>\n"
    "Copyright (C) 2020-2023 наб <nabijaczleweli@nabijaczleweli.xyz>\n"

CLI Version: Authors' copyrights.

Definition at line 71 of file version.c.

Thanks

const char* Thanks

static

Initial value:

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

CLI Version: Thanks.

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")

CLI Version: License.

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")

CLI Version: How to reach the NeoMutt Team.

Definition at line 104 of file version.c.

Notice

const char* Notice

static

Initial value:

=
    N_("Copyright (C) 2015-2024 Richard Russon and friends\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")

CLI Version: Warranty notice.

Definition at line 111 of file version.c.

CompOpts

const struct CompileOptions CompOpts[]

static

Compile options strings for neomutt -v output.

Definition at line 130 of file version.c.

DebugOpts

const struct CompileOptions DebugOpts[]

static

Debug options strings for neomutt -v output.

Definition at line 266 of file version.c.