NeoMutt  2022-04-29-215-gc12b98
Teaching an old dog new tricks
DOXYGEN
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...
 
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 1470 of file muttlib.c.

1471{
1472 static char vstring[256];
1473 snprintf(vstring, sizeof(vstring), "NeoMutt %s%s", PACKAGE_VERSION, GitVer);
1474 return vstring;
1475}
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:250
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 334 of file version.c.

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

387{
388 if (!s)
389 return NULL;
390
391 char *p = &s[strlen(s)];
392 if (p == s)
393 return s;
394 p--;
395 while ((p >= s) && ((*p == '\n') || (*p == '\r')))
396 *p-- = '\0';
397 return s;
398}
+ 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 408 of file version.c.

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

537{
538 puts(mutt_make_version());
539 puts(Copyright);
540 puts(_(Thanks));
541 puts(_(License));
542 puts(_(ReachingUs));
543
544 fflush(stdout);
545 return !ferror(stdout);
546}
static const char * Thanks
Definition: version.c:84
static const char * License
Definition: version.c:87
static const char * Copyright
Definition: version.c:72
+ 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 563 of file version.c.

564{
565 if (!name)
566 return false;
567 for (int i = 0; comp_opts_default[i].name; i++)
568 {
569 if (mutt_str_equal(name, comp_opts_default[i].name))
570 {
571 return true;
572 }
573 }
574 for (int i = 0; comp_opts[i].name; i++)
575 {
576 if (mutt_str_equal(name, comp_opts[i].name))
577 {
578 return comp_opts[i].enabled;
579 }
580 }
581 return false;
582}
bool mutt_str_equal(const char *a, const char *b)
Compare two strings.
Definition: string.c:807
int enabled
0 Disabled, 1 Enabled, 2 Devel only
Definition: version.c:121
+ 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[]
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-2022 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")
#define N_(a)
Definition: message.h:32

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 87 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 102 of file version.c.

◆ Notice

const char* Notice
static
Initial value:
=
N_("Copyright (C) 1996-2022 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 108 of file version.c.

◆ comp_opts_default

struct CompileOptions comp_opts_default[]
static

Definition at line 126 of file version.c.

◆ comp_opts

struct CompileOptions comp_opts[]
static

Definition at line 160 of file version.c.

◆ debug_opts

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

Definition at line 290 of file version.c.