NeoMutt  2021-10-22-8-g9cb437
Teaching an old dog new tricks
DOXYGEN
version.c File Reference

Display version and copyright about NeoMutt. More...

#include "config.h"
#include <errno.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...
 
bool print_version (FILE *fp)
 Print system and compile info to a file. More...
 
bool 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 []
 
static struct CompileOptions debug_opts []
 

Detailed Description

Display version and copyright about NeoMutt.

Authors
  • Michael R. Elkins
  • Thomas Roessler
  • Richard Russon

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
ptrVersion string
Note
This returns a pointer to a static buffer

Definition at line 1476 of file muttlib.c.

1477 {
1478  static char vstring[256];
1479  snprintf(vstring, sizeof(vstring), "NeoMutt %s%s", PACKAGE_VERSION, GitVer);
1480  return vstring;
1481 }
const char * GitVer
+ 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
ptrComma-space-separated list of names

The caller should free the string.

Definition at line 84 of file store.c.

85 {
86  char tmp[256] = { 0 };
87  const struct StoreOps **ops = StoreOps;
88  size_t len = 0;
89 
90  for (; *ops; ops++)
91  {
92  if (len != 0)
93  {
94  len += snprintf(tmp + len, sizeof(tmp) - len, ", ");
95  }
96  len += snprintf(tmp + len, sizeof(tmp) - len, "%s", (*ops)->name);
97  }
98 
99  return mutt_str_dup(tmp);
100 }
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:370
static const struct StoreOps * StoreOps[]
Backend implementations.
Definition: store.c:50
Definition: lib.h:66
+ 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
coArray of compile options
fpfile 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 329 of file version.c.

330 {
331  if (!co || !fp)
332  return;
333 
334  size_t used = 2;
335  bool tty = isatty(fileno(fp));
336 
337  fprintf(fp, " ");
338  for (int i = 0; co[i].name; i++)
339  {
340  const size_t len = strlen(co[i].name) + 2; /* +/- and a space */
341  if ((used + len) > SCREEN_WIDTH)
342  {
343  used = 2;
344  fprintf(fp, "\n ");
345  }
346  used += len;
347  const char *fmt = "?%s ";
348  switch (co[i].enabled)
349  {
350  case 0: // Disabled
351  if (tty)
352  fmt = "\033[1;31m-%s\033[0m "; // Escape, red
353  else
354  fmt = "-%s ";
355  break;
356  case 1: // Enabled
357  if (tty)
358  fmt = "\033[1;32m+%s\033[0m "; // Escape, green
359  else
360  fmt = "+%s ";
361  break;
362  case 2: // Devel only
363  if (tty)
364  fmt = "\033[1;36m%s\033[0m "; // Escape, cyan
365  else
366  fmt = "%s ";
367  break;
368  }
369  fprintf(fp, fmt, co[i].name);
370  }
371  fprintf(fp, "\n");
372 }
const char * name
Option name.
Definition: version.c:124
const int SCREEN_WIDTH
Definition: version.c:68
+ 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
sString to be modified
Return values
ptrThe modified string

The string has its last carriage return set to NUL.

Definition at line 381 of file version.c.

382 {
383  if (!s)
384  return NULL;
385 
386  char *p = &s[strlen(s)];
387  if (p == s)
388  return s;
389  p--;
390  while ((p >= s) && ((*p == '\n') || (*p == '\r')))
391  *p-- = '\0';
392  return s;
393 }
+ Here is the caller graph for this function:

◆ print_version()

bool print_version ( FILE *  fp)

Print system and compile info to a file.

Parameters
fpFile to print to
Return values
trueText displayed

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

Definition at line 403 of file version.c.

404 {
405  if (!fp)
406  return false;
407 
408  struct utsname uts;
409  bool tty = isatty(fileno(fp));
410  const char *fmt = "%s\n";
411 
412  if (tty)
413  fmt = "\033[1;36m%s\033[0m\n"; // Escape, cyan
414 
415  fprintf(fp, fmt, mutt_make_version());
416  fprintf(fp, "%s\n", _(Notice));
417 
418  uname(&uts);
419 
420 #ifdef SCO
421  fprintf(fp, "System: SCO %s", uts.release);
422 #else
423  fprintf(fp, "System: %s %s", uts.sysname, uts.release);
424 #endif
425 
426  fprintf(fp, " (%s)", uts.machine);
427 
428  fprintf(fp, "\nncurses: %s (compiled with %s.%d)", curses_version(),
429  NCURSES_VERSION, NCURSES_VERSION_PATCH);
430 
431 #ifdef _LIBICONV_VERSION
432  fprintf(fp, "\nlibiconv: %d.%d", _LIBICONV_VERSION >> 8, _LIBICONV_VERSION & 0xff);
433 #endif
434 
435 #ifdef HAVE_LIBIDN
436  fprintf(fp, "\n%s", mutt_idna_print_version());
437 #endif
438 
439 #ifdef CRYPT_BACKEND_GPGME
440  fprintf(fp, "\nGPGME: %s", mutt_gpgme_print_version());
441 #endif
442 
443 #ifdef USE_SSL_OPENSSL
444 #ifdef LIBRESSL_VERSION_TEXT
445  fprintf(fp, "\nLibreSSL: %s", LIBRESSL_VERSION_TEXT);
446 #endif
447 #ifdef OPENSSL_VERSION_TEXT
448  fprintf(fp, "\nOpenSSL: %s", OPENSSL_VERSION_TEXT);
449 #endif
450 #endif
451 
452 #ifdef USE_SSL_GNUTLS
453  fprintf(fp, "\nGnuTLS: %s", GNUTLS_VERSION);
454 #endif
455 
456 #ifdef HAVE_NOTMUCH
457  fprintf(fp, "\nlibnotmuch: %d.%d.%d", LIBNOTMUCH_MAJOR_VERSION,
458  LIBNOTMUCH_MINOR_VERSION, LIBNOTMUCH_MICRO_VERSION);
459 #endif
460 
461 #ifdef HAVE_PCRE2
462  {
463  char version[24];
464  pcre2_config(PCRE2_CONFIG_VERSION, version);
465  fprintf(fp, "\nPCRE2: %s", version);
466  }
467 #endif
468 
469 #ifdef USE_HCACHE
470  const char *backends = store_backend_list();
471  fprintf(fp, "\nstorage: %s", backends);
472  FREE(&backends);
473 #ifdef USE_HCACHE_COMPRESSION
474  backends = compress_list();
475  fprintf(fp, "\ncompression: %s", backends);
476  FREE(&backends);
477 #endif
478 #endif
479 
481  fprintf(fp, "\n\nConfigure options: %s\n", (char *) configure_options);
482 
483  rstrip_in_place((char *) cc_cflags);
484  fprintf(fp, "\nCompilation CFLAGS: %s\n", (char *) cc_cflags);
485 
486  fprintf(fp, "\n%s\n", _("Default options:"));
488 
489  fprintf(fp, "\n%s\n", _("Compile options:"));
491 
492  if (debug_opts[0].name)
493  {
494  fprintf(fp, "\n%s\n", _("Debug options:"));
496  }
497 
498  fprintf(fp, "\n");
499 #ifdef DOMAIN
500  fprintf(fp, "DOMAIN=\"%s\"\n", DOMAIN);
501 #endif
502 #ifdef ISPELL
503  fprintf(fp, "ISPELL=\"%s\"\n", ISPELL);
504 #endif
505  fprintf(fp, "MAILPATH=\"%s\"\n", MAILPATH);
506 #ifdef MIXMASTER
507  fprintf(fp, "MIXMASTER=\"%s\"\n", MIXMASTER);
508 #endif
509  fprintf(fp, "PKGDATADIR=\"%s\"\n", PKGDATADIR);
510  fprintf(fp, "SENDMAIL=\"%s\"\n", SENDMAIL);
511  fprintf(fp, "SYSCONFDIR=\"%s\"\n", SYSCONFDIR);
512 
513  fprintf(fp, "\n");
514  fputs(_(ReachingUs), fp);
515 
516  fflush(fp);
517  return !ferror(fp);
518 }
#define ISPELL
Definition: config.c:34
const char * compress_list(void)
Get a list of compression backend names.
Definition: compress.c:57
const char * mutt_gpgme_print_version(void)
Get version of GPGME.
Definition: crypt_gpgme.c:4476
const char * mutt_idna_print_version(void)
Create an IDN version string.
Definition: idna.c:314
#define FREE(x)
Definition: memory.h:40
#define _(a)
Definition: message.h:28
const char * store_backend_list(void)
Get a list of backend names.
Definition: store.c:84
static void print_compile_options(struct CompileOptions *co, FILE *fp)
Print a list of enabled/disabled features.
Definition: version.c:329
static const char * ReachingUs
Definition: version.c:105
static struct CompileOptions comp_opts_default[]
Definition: version.c:130
static struct CompileOptions debug_opts[]
Definition: version.c:294
static char * rstrip_in_place(char *s)
Strip a trailing carriage return.
Definition: version.c:381
unsigned char configure_options[]
const char * mutt_make_version(void)
Generate the NeoMutt version string.
Definition: muttlib.c:1476
unsigned char cc_cflags[]
static const char * Notice
Definition: version.c:112
static struct CompileOptions comp_opts[]
Definition: version.c:164
+ 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
trueText displayed

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

Definition at line 527 of file version.c.

528 {
529  puts(mutt_make_version());
530  puts(Copyright);
531  puts(_(Thanks));
532  puts(_(License));
533  puts(_(ReachingUs));
534 
535  fflush(stdout);
536  return !ferror(stdout);
537 }
static const char * Thanks
Definition: version.c:85
static const char * License
Definition: version.c:89
static const char * Copyright
Definition: version.c:73
+ 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
nameCompile-time symbol of the feature
Return values
trueFeature enabled
falseFeature 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 554 of file version.c.

555 {
556  if (!name)
557  return false;
558  for (int i = 0; comp_opts_default[i].name; i++)
559  {
560  if (mutt_str_equal(name, comp_opts_default[i].name))
561  {
562  return true;
563  }
564  }
565  for (int i = 0; comp_opts[i].name; i++)
566  {
567  if (mutt_str_equal(name, comp_opts[i].name))
568  {
569  return comp_opts[i].enabled;
570  }
571  }
572  return false;
573 }
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:904
int enabled
0 Disabled, 1 Enabled, 2 Devel only
Definition: version.c:125
+ Here is the call graph for this function:

Variable Documentation

◆ SCREEN_WIDTH

const int SCREEN_WIDTH = 80

Definition at line 68 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) 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 73 of file version.c.

◆ Thanks

const char* Thanks
static
Initial value:
=
N_("Many others not mentioned here contributed code, fixes,\n"
"and suggestions.\n")
#define N_(a)
Definition: message.h:32

Definition at line 85 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 89 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 105 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 112 of file version.c.

◆ comp_opts_default

struct CompileOptions comp_opts_default[]
static

Definition at line 112 of file version.c.

◆ comp_opts

struct CompileOptions comp_opts[]
static

Definition at line 112 of file version.c.

◆ debug_opts

struct CompileOptions debug_opts[]
static
Initial value:
= {
{ NULL, 0 },
}

Definition at line 112 of file version.c.