sq krb_pa_supported_enctypes
[metze/wireshark/wip.git] / version_info.c
1 /* version_info.c
2  * Routines to report version information for Wireshark programs
3  *
4  * Wireshark - Network traffic analyzer
5  * By Gerald Combs <gerald@wireshark.org>
6  * Copyright 1998 Gerald Combs
7  *
8  * SPDX-License-Identifier: GPL-2.0-or-later
9  */
10
11 #include <config.h>
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <locale.h>
17
18 #ifdef _WIN32
19 #include <windows.h>
20 #elif __APPLE__
21 #include <sys/types.h>
22 #include <sys/sysctl.h>
23 #elif __linux__
24 #include <sys/sysinfo.h>
25 #endif
26
27 #include <glib.h>
28
29 #ifdef HAVE_ZLIB
30 #include <zlib.h>
31 #endif
32
33 #include "version.h"
34
35 #include "version_info.h"
36
37 #include <wsutil/cpu_info.h>
38 #include <wsutil/copyright_info.h>
39 #include <wsutil/os_version_info.h>
40 #include <wsutil/crash_info.h>
41 #include <wsutil/ws_printf.h> /* ws_debug_printf */
42 #include <wsutil/plugins.h>
43
44 static char *appname_with_version;
45 static char *comp_info;
46 static char *runtime_info;
47
48 void
49 ws_init_version_info(const char *appname,
50     void (*prepend_compile_time_info)(GString *),
51     void (*append_compile_time_info)(GString *),
52     void (*additional_run_time_info)(GString *))
53 {
54         GString *comp_info_str, *runtime_info_str;
55
56         /*
57          * Combine the supplied application name string with the
58          * version - including the VCS version, for a build from
59          * a checkout.
60          */
61         appname_with_version = g_strdup_printf("%s %s",
62             appname, get_ws_vcs_version_info());
63
64         /* Get the compile-time version information string */
65         comp_info_str = get_compiled_version_info(prepend_compile_time_info,
66             append_compile_time_info);
67
68         /* Get the run-time version information string */
69         runtime_info_str = get_runtime_version_info(additional_run_time_info);
70
71         comp_info = g_string_free(comp_info_str, FALSE);
72         runtime_info = g_string_free(runtime_info_str, FALSE);
73
74         /* Add this information to the information to be reported on a crash. */
75         ws_add_crash_info("%s\n"
76             "\n"
77             "%s\n"
78             "%s",
79             appname_with_version, comp_info, runtime_info);
80 }
81
82 const char *
83 get_appname_and_version(void)
84 {
85         return appname_with_version;
86 }
87
88 /*
89  * If the string doesn't end with a newline, append one.
90  * Then word-wrap it to 80 columns.
91  */
92 static void
93 end_string(GString *str)
94 {
95         size_t point;
96         char *p, *q;
97
98         point = str->len;
99         if (point == 0 || str->str[point - 1] != '\n')
100                 g_string_append(str, "\n");
101         p = str->str;
102         while (*p != '\0') {
103                 q = strchr(p, '\n');
104                 if (q - p > 80) {
105                         /*
106                          * Break at or before this point.
107                          */
108                         q = p + 80;
109                         while (q > p && *q != ' ')
110                                 q--;
111                         if (q != p)
112                                 *q = '\n';
113                 }
114                 p = q + 1;
115         }
116 }
117
118 static const gchar *
119 get_zlib_compiled_version_info(void)
120 {
121 #ifdef HAVE_ZLIB
122 #ifdef ZLIB_VERSION
123         return "with zlib "ZLIB_VERSION;
124 #else
125         return "with zlib (version unknown)";
126 #endif /* ZLIB_VERSION */
127 #else
128         return "without zlib";
129 #endif /* HAVE_ZLIB */
130 }
131
132 /*
133  * Get various library compile-time versions, put them in a GString,
134  * and return the GString.
135  *
136  * "prepend_info" is called at the start to prepend any additional
137  * information before the standard library information.
138  *
139  * "append_info" is called at the end to append any additional
140  * information after the standard library information.  This is
141  * required in order to, for example, put Qt information at the
142  * end of the string, as we don't use Qt in TShark.
143  */
144 GString *
145 get_compiled_version_info(void (*prepend_info)(GString *),
146                           void (*append_info)(GString *))
147 {
148         GString *str;
149
150         str = g_string_new("Compiled ");
151
152         if (sizeof(str) == 4)
153                 g_string_append(str, "(32-bit) ");
154         else
155                 g_string_append(str, "(64-bit) ");
156
157         if (prepend_info) {
158                 (*prepend_info)(str);
159                 g_string_append(str, ", ");
160         }
161
162         /* GLIB */
163         g_string_append(str, "with ");
164         g_string_append_printf(str,
165 #ifdef GLIB_MAJOR_VERSION
166             "GLib %d.%d.%d", GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION,
167             GLIB_MICRO_VERSION);
168 #else
169             "GLib (version unknown)");
170 #endif
171
172         g_string_append_printf(str, ", %s", get_zlib_compiled_version_info());
173
174         /* Additional application-dependent information */
175         if (append_info)
176                 (*append_info)(str);
177         g_string_append(str, ".");
178
179         end_string(str);
180
181         return str;
182 }
183
184 static void
185 get_mem_info(GString *str)
186 {
187         gint64 memsize = 0;
188
189 #ifdef _WIN32
190         MEMORYSTATUSEX statex;
191
192         statex.dwLength = sizeof (statex);
193
194         if (GlobalMemoryStatusEx(&statex))
195                 memsize = statex.ullTotalPhys;
196 #elif __APPLE__
197         size_t len = sizeof(memsize);
198         sysctlbyname("hw.memsize", &memsize, &len, NULL, 0);
199 #elif __linux__
200         struct sysinfo info;
201         if (sysinfo(&info) == 0)
202                 memsize = info.totalram * info.mem_unit;
203 #endif
204
205         if (memsize > 0)
206                 g_string_append_printf(str, ", with ""%" G_GINT64_MODIFIER "d" " MB of physical memory", memsize/(1024*1024));
207 }
208
209 /*
210  * Get compiler information, and append it to the GString.
211  */
212 static void
213 get_compiler_info(GString *str)
214 {
215         /*
216          * See https://sourceforge.net/apps/mediawiki/predef/index.php?title=Compilers
217          * information on various defined strings.
218          *
219          * GCC's __VERSION__ is a nice text string for humans to
220          * read.  The page at sourceforge.net largely describes
221          * numeric #defines that encode the version; if the compiler
222          * doesn't also offer a nice printable string, we try prettifying
223          * the number somehow.
224          */
225 #if defined(_MSC_FULL_VER)
226         /*
227          * We check for this first, as Microsoft have a version of their
228          * compiler that has Clang as the front end and their code generator
229          * as the back end.
230          *
231          * My head asplode.
232          */
233
234         /* As of Wireshark 3.0, we support only Visual Studio 2015 (14.x)
235          * or later.
236          *
237          * https://dev.to/yumetodo/list-of-mscver-and-mscfullver-8nd
238          * has a *large* table of Microsoft product names, VC++ versions,
239          * _MSC_VER values, and _MSC_FULL_VER values.  All the versions
240          * we support define _MSC_FULL_VER.  We don't bother trying to
241          * get the SP/update/version number from the build number, as
242          * we'd have to keep updating that with every update; there's no
243          * way to get that information directly from a predefine, and in
244          * some cases multiple updates/versions have the *same* build
245          * number (because they didn't update the toolchain).
246          *
247          * https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros?view=vs-2017
248          * defines the format of _MSC_VER and _MSC_FULL_VER.  _MSC_FULL_VER
249          * is a decimal number of the form MMmmBBBBB, where MM is the compiler/
250          * toolchain major version, mm is the minor version, and BBBBB is the
251          * build.  We break it down based on that.
252          */
253   #define COMPILER_MAJOR_VERSION         (_MSC_FULL_VER / 10000000)
254   #define COMPILER_MINOR_VERSION        ((_MSC_FULL_VER % 10000000) / 100000)
255   #define COMPILER_BUILD_NUMBER          (_MSC_FULL_VER % 100000)
256
257         /*
258          * From https://blogs.msdn.microsoft.com/vcblog/2014/11/17/c111417-features-in-vs-2015-preview/
259          *
260          *  Bakersfield: DevDiv's upper management determines the scheduling
261          *  of new major versions.  They also decided to increment the product
262          *  version from 12 (for VS 2013) to 14 (for VS 2015).  However, the
263          *  C++ compiler's version incremented normally, from 18 to 19.
264          *  (It's larger because the C++ compiler predates the "Visual" in
265          *  Visual C++.)
266          *
267          * So the product version number is 5 less than the compiler version
268          * number.
269          */
270   #define VCPP_MAJOR_VERSION    (COMPILER_MAJOR_VERSION - 5)
271
272   #if VCPP_MAJOR_VERSION == 14
273         /*
274          * From https://blogs.msdn.microsoft.com/vcblog/2017/11/15/side-by-side-minor-version-msvc-toolsets-in-visual-studio-2017/:
275          *
276          *  We've been delivering improvements to Visual Studio 2017 more
277          *  frequently than ever before. Since its first release in March
278          *  we've released four major updates to VS2017 and are currently
279          *  previewing the fifth update, VS2017 version 15.5.
280          *
281          *  The MSVC toolset in VS2017 is built as a minor version update to
282          *  the VS2015 compiler toolset. This minor version bump indicates
283          *  that the VS2017 MSVC toolset is binary compatible with the VS2015
284          *  MSVC toolset, enabling an easier upgrade for VS2015 users. Even
285          *  though the MSVC compiler toolset in VS2017 delivers many new
286          *  features and conformance improvements it is a minor version,
287          *  compatible update from 14.00 in VS2015 to 14.10 in VS2017.
288          */
289     #if COMPILER_MINOR_VERSION < 10
290       #define VS_VERSION        "2015"
291     #else
292       #define VS_VERSION        "2017"
293     #endif
294   #else
295     /*
296      * Add additional checks here, before the #else.
297      */
298     #define VS_VERSION  "(unknown)"
299   #endif /* VCPP_MAJOR_VERSION */
300
301         /*
302          * XXX - should we show the raw compiler version number, as is
303          * shown by "cl /?", which would be %d.%d.%d.%d with
304          * COMPILER_MAJOR_VERSION, COMPILER_MINOR_VERSION,
305          * COMPILER_BUILD_NUMBER, and _MSC_BUILD, the last of which is
306          * "the revision number element of the compiler's version number",
307          * which I guess is not to be confused with the build number,
308          * the _BUILD in the name nonwithstanding.
309          */
310         g_string_append_printf(str, "\n\nBuilt using Microsoft Visual Studio " VS_VERSION " (VC++ %d.%d, build %d)",
311             VCPP_MAJOR_VERSION, COMPILER_MINOR_VERSION, COMPILER_BUILD_NUMBER);
312   #if defined(__clang__)
313         /*
314          * See above.
315          */
316         g_string_append_printf(str, " clang/C2 %s and -fno-ms-compatibility.\n",
317             __VERSION__);
318   #else
319         g_string_append_printf(str, ".\n");
320   #endif
321 #elif defined(__GNUC__) && defined(__VERSION__)
322         /*
323          * Clang and llvm-gcc also define __GNUC__ and __VERSION__;
324          * distinguish between them.
325          */
326   #if defined(__clang__)
327         /*
328          * We know this isn't clang/C2, as _MSC_FULL_VER isn't defined.
329          */
330         g_string_append_printf(str, "\n\nBuilt using clang %s.\n", __VERSION__);
331   #elif defined(__llvm__)
332         /* llvm-gcc */
333         g_string_append_printf(str, "\n\nBuilt using llvm-gcc %s.\n", __VERSION__);
334   #else /* boring old GCC */
335         g_string_append_printf(str, "\n\nBuilt using gcc %s.\n", __VERSION__);
336   #endif /* llvm */
337 #elif defined(__HP_aCC)
338         g_string_append_printf(str, "\n\nBuilt using HP aCC %d.\n", __HP_aCC);
339 #elif defined(__xlC__)
340         g_string_append_printf(str, "\n\nBuilt using IBM XL C %d.%d\n",
341             (__xlC__ >> 8) & 0xFF, __xlC__ & 0xFF);
342   #ifdef __IBMC__
343         if ((__IBMC__ % 10) != 0)
344                 g_string_append_printf(str, " patch %d", __IBMC__ % 10);
345   #endif /* __IBMC__ */
346         g_string_append_printf(str, "\n");
347 #elif defined(__INTEL_COMPILER)
348         g_string_append_printf(str, "\n\nBuilt using Intel C %d.%d",
349             __INTEL_COMPILER / 100, (__INTEL_COMPILER / 10) % 10);
350         if ((__INTEL_COMPILER % 10) != 0)
351                 g_string_append_printf(str, " patch %d", __INTEL_COMPILER % 10);
352   #ifdef __INTEL_COMPILER_BUILD_DATE
353         g_string_sprinta(str, ", compiler built %04d-%02d-%02d",
354             __INTEL_COMPILER_BUILD_DATE / 10000,
355             (__INTEL_COMPILER_BUILD_DATE / 100) % 100,
356             __INTEL_COMPILER_BUILD_DATE % 100);
357   #endif /* __INTEL_COMPILER_BUILD_DATE */
358         g_string_append_printf(str, "\n");
359 #elif defined(__SUNPRO_C)
360         g_string_append_printf(str, "\n\nBuilt using Sun C %d.%d",
361             (__SUNPRO_C >> 8) & 0xF, (__SUNPRO_C >> 4) & 0xF);
362         if ((__SUNPRO_C & 0xF) != 0)
363                 g_string_append_printf(str, " patch %d", __SUNPRO_C & 0xF);
364         g_string_append_printf(str, "\n");
365 #endif
366 }
367
368 /* XXX - is the setlocale() return string opaque? For glibc the separator is ';' */
369 static gchar *
370 get_locale(void)
371 {
372         const gchar *lang;
373         gchar **locv, *loc;
374
375         lang = setlocale(LC_ALL, NULL);
376         if (lang == NULL) {
377                 return NULL;
378         }
379
380         locv = g_strsplit(lang, ";", -1);
381         loc = g_strjoinv(", ", locv);
382         g_strfreev(locv);
383         return loc;
384 }
385
386 /*
387  * Get various library run-time versions, and the OS version, and append
388  * them to the specified GString.
389  *
390  * "additional_info" is called at the end to append any additional
391  * information; this is required in order to, for example, put the
392  * libcap information at the end of the string, as we currently
393  * don't use libcap in TShark.
394  */
395 GString *
396 get_runtime_version_info(void (*additional_info)(GString *))
397 {
398         GString *str;
399         gchar *lang;
400
401         str = g_string_new("Running on ");
402
403         get_os_version_info(str);
404
405         /* CPU Info */
406         get_cpu_info(str);
407
408         /* Get info about installed memory */
409         get_mem_info(str);
410
411         /*
412          * Locale.
413          *
414          * This returns the C language's locale information; this
415          * returns the locale that's actually in effect, even if
416          * it doesn't happen to match the settings of any of the
417          * locale environment variables.
418          *
419          * On Windows get_locale returns the full language, country
420          * name, and code page, e.g. "English_United States.1252":
421          * https://msdn.microsoft.com/en-us/library/x99tb11d.aspx
422          */
423         if ((lang = get_locale()) != NULL) {
424                 g_string_append_printf(str, ", with locale %s", lang);
425                 g_free(lang);
426         }
427         else {
428                 g_string_append(str, ", with default locale");
429         }
430
431
432         /* Additional application-dependent information */
433         if (additional_info)
434                 (*additional_info)(str);
435
436         /* zlib */
437 #if defined(HAVE_ZLIB) && !defined(_WIN32)
438         g_string_append_printf(str, ", with zlib %s", zlibVersion());
439 #endif
440
441         /* plugins */
442 #ifdef HAVE_PLUGINS
443         if (g_module_supported()) {
444                 g_string_append_printf(str, ", binary plugins supported (%d loaded)", plugins_get_count());
445         }
446         else {
447                 g_string_append(str, ", binary plugins not supported");
448         }
449 #endif
450
451         g_string_append(str, ".");
452
453         /* Compiler info */
454         get_compiler_info(str);
455
456         end_string(str);
457
458         return str;
459 }
460
461 /*
462  * Return a version number string for Wireshark, including, for builds
463  * from a tree checked out from Wireshark's version control system,
464  * something identifying what version was checked out.
465  */
466 const char *
467 get_ws_vcs_version_info(void)
468 {
469 #ifdef VCSVERSION
470         return VERSION " (" VCSVERSION ")";
471 #else
472         return VERSION;
473 #endif
474 }
475
476 void
477 get_ws_version_number(int *major, int *minor, int *micro)
478 {
479         if (major)
480                 *major = VERSION_MAJOR;
481         if (minor)
482                 *minor = VERSION_MINOR;
483         if (micro)
484                 *micro = VERSION_MICRO;
485 }
486
487 void
488 show_version(void)
489 {
490         ws_debug_printf("%s\n"
491                "\n"
492                "%s\n"
493                "%s\n"
494                "%s",
495                appname_with_version, get_copyright_info(),
496                comp_info, runtime_info);
497 }
498
499 void
500 show_help_header(const char *description)
501 {
502         ws_debug_printf("%s\n"
503                 "%s\n"
504                 "See https://www.wireshark.org for more information.\n",
505                 appname_with_version, description);
506 }
507
508 /*
509  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
510  *
511  * Local variables:
512  * c-basic-offset: 8
513  * tab-width: 8
514  * indent-tabs-mode: t
515  * End:
516  *
517  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
518  * :indentSize=8:tabSize=8:noTabs=false:
519  */