#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:

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 1462 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

Definition at line 129 of file version.c.

◆ comp_opts

struct CompileOptions comp_opts[]

static

Definition at line 163 of file version.c.

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ mutt_make_version()

◆ store_backend_list()

◆ store_compress_list()

◆ print_compile_options()

◆ rstrip_in_place()

◆ print_version()

◆ print_copyright()

◆ feature_enabled()

Variable Documentation

◆ SCREEN_WIDTH

◆ cc_cflags

◆ configure_options

◆ Copyright

◆ Thanks

◆ License

◆ ReachingUs

◆ Notice

◆ comp_opts_default

◆ comp_opts