1 /*****************************************************************************\
3 * Name : check_version *
4 * Author : Chris Koeritz *
6 *******************************************************************************
7 * Copyright (c) 1996-$now By Author. This program is free software; you can *
8 * redistribute it and/or modify it under the terms of the GNU General Public *
9 * License as published by the Free Software Foundation; either version 2 of *
10 * the License or (at your option) any later version. This is online at: *
11 * http://www.fsf.org/copyleft/gpl.html *
12 * Please send any updates to: fred@gruntose.com *
13 \*****************************************************************************/
15 #include "version_checker.h"
17 #include <application/windoze_helper.h>
18 #include <basis/astring.h>
19 #include <basis/environment.h>
20 #include <basis/functions.h>
21 #include <basis/guards.h>
22 #include <basis/utf_conversion.h>
23 #include <configuration/application_configuration.h>
24 #include <filesystem/filename.h>
25 #include <loggers/critical_events.h>
29 using namespace basis;
30 using namespace configuration;
31 using namespace loggers;
32 using namespace structures;
34 #ifndef BOOT_STRAPPING
35 // pull in the version specified for this build.
36 #include <__build_version.h>
37 //why was this include "on hold"?
39 // plug in a fake version for our bootstrapping process.
40 #define __build_FILE_VERSION "108.420.1024.10008"
44 // #include <direct.h>
49 // ensures that we handle the data properly regardless of unicode settings.
51 #define render_ptr(ptr) from_unicode_temp( (UTF16 *) ptr)
53 #define render_ptr(ptr) ( (char *) ptr)
61 version_checker::version_checker(const astring &library_file_name,
62 const version &expected_version, const astring &version_complaint)
63 : _library_file_name(new astring(library_file_name)),
64 _expected_version(new version(expected_version)),
65 _version_complaint(new astring(version_complaint))
68 version_checker::~version_checker()
70 WHACK(_library_file_name);
71 WHACK(_expected_version);
72 WHACK(_version_complaint);
75 astring version_checker::text_form() const
77 return astring(class_name()) + ": library_file_name=" + *_library_file_name
78 + ", expected_version=" + _expected_version->text_form()
79 + ", complaint_message=" + *_version_complaint;
82 bool version_checker::good_version() const
84 astring version_disabler = environment::TMP();
85 version_disabler += "/no_version_check.txt";
86 FILE *always_okay = fopen(version_disabler.s(), "r");
92 version version_found = retrieve_version(*_library_file_name);
93 if (version_found.compatible(*_expected_version)) return true; // success.
94 complain_wrong_version(*_library_file_name, *_expected_version,
99 bool version_checker::loaded(const astring &library_file_name)
102 #if defined(__WIN32__)
103 return bool(get_handle(library_file_name) != 0);
106 return true || library_file_name.t();
110 void *version_checker::get_handle(const astring &library_file_name)
113 #if defined(__WIN32__)
114 return GetModuleHandle(to_unicode_temp(library_file_name));
116 if (library_file_name.t()) return NULL_POINTER; else return NULL_POINTER;
120 astring version_checker::module_name(const void *module_handle)
122 #if defined(__UNIX__)
123 //|| defined(__GNU_WINDOWS__)
124 if (module_handle) {}
125 return application_configuration::application_name();
126 #elif defined(__WIN32__)
127 //#elif defined(__WIN32__)
128 flexichar low_buff[MAX_ABS_PATH + 1];
129 GetModuleFileName((HMODULE)module_handle, low_buff, MAX_ABS_PATH - 1);
130 astring buff = from_unicode_temp(low_buff);
134 #pragma message("module_name unknown for this operating system.")
135 return application_configuration::application_name();
139 astring version_checker::get_name(const void *to_find)
140 { return module_name(to_find); }
142 bool version_checker::retrieve_version_info(const astring &filename,
145 to_fill.reset(); // clear the buffer.
147 // determine the required size of the version info buffer.
149 #if defined(__WIN32__)
151 DWORD module_handle; // filled with the dll or exe handle.
152 required_size = GetFileVersionInfoSize(to_unicode_temp(filename), &module_handle);
154 required_size = 0 && filename.t();
156 if (!required_size) return false;
157 to_fill.reset(required_size); // resize the buffer.
159 // read the version info into our buffer.
160 bool success = false;
161 #if defined(__WIN32__)
163 success = GetFileVersionInfo(to_unicode_temp(filename), module_handle,
164 required_size, to_fill.access());
171 bool version_checker::get_language(byte_array &version_chunk,
172 basis::un_short &high, basis::un_short &low)
176 #if defined(__WIN32__)
178 // determine the language that the version's written in.
179 basis::un_int data_size;
180 void *pointer_to_language_structure;
181 // query the information from the version blob.
182 if (!VerQueryValue(version_chunk.access(),
183 to_unicode_temp("\\VarFileInfo\\Translation"),
184 &pointer_to_language_structure, &data_size))
186 // get the low & high shorts of the structure.
187 high = LOWORD(*(unsigned int *)pointer_to_language_structure);
188 low = HIWORD(*(unsigned int *)pointer_to_language_structure);
190 high = 0 && version_chunk.length();
197 version version_checker::retrieve_version(const astring &filename)
200 #if defined(__UNIX__)
201 // || defined(__GNU_WINDOWS__)
203 // totally bogus stand-in; this just returns the version we were built with
204 // rather than the version that's actually tagged on the file.
206 //hmmm: fix this! get the version header back.
207 // return version(__build_FILE_VERSION);
212 byte_array version_info_found(0, NULL_POINTER);
213 if (!retrieve_version_info(filename, version_info_found))
214 return version(0, 0, 0, 0);
216 basis::un_short high, low; // holds the language of the version data.
217 if (!get_language(version_info_found, high, low))
218 return version(0, 0, 0, 0);
220 // retrieve the file version from version info using the appropriate
222 astring root_key(astring::SPRINTF, "\\StringFileInfo\\%04x%04x", high, low);
223 astring file_version_key(root_key + astring("\\FileVersion"));
225 astring version_string;
227 abyte *file_version_pointer;
228 basis::un_int data_size;
229 if (!VerQueryValue(version_info_found.access(),
230 to_unicode_temp(file_version_key),
231 (LPVOID *)&file_version_pointer, &data_size))
232 return version(0, 0, 0, 0);
233 version_string = render_ptr(file_version_pointer);
234 // clean any spaces out of the string; people sometimes format these
236 for (int i = 0; i < version_string.length(); i++) {
237 if (version_string[i] == ' ') {
238 version_string.zap(i, i);
239 i--; // skip back a beat.
243 return version(0, 0, 0, 0);
246 return version::from_text(version_string);
249 bool version_checker::get_record(const astring &filename,
250 version_record &to_fill)
252 to_fill = version_record();
253 byte_array version_info_found(0, NULL_POINTER);
254 if (!retrieve_version_info(filename, version_info_found))
257 basis::un_short high, low; // holds the language of the version data.
258 if (!get_language(version_info_found, high, low))
261 // set the root key for all accesses of the version chunk.
262 astring root_key(astring::SPRINTF, "\\StringFileInfo\\%04x%04x", high, low);
264 // reports whether all lookups succeeded or not.
265 bool total_success = true;
267 // the various version pieces are retrieved...
271 basis::un_int data_size;
275 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
276 + astring("\\FileVersion")), &data_pointer, &data_size))
277 total_success = false;
279 to_fill.file_version = version::from_text(render_ptr(data_pointer));
282 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
283 + astring("\\CompanyName")), &data_pointer, &data_size))
284 total_success = false;
286 to_fill.company_name = render_ptr(data_pointer);
289 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
290 + astring("\\FileDescription")), &data_pointer, &data_size))
291 total_success = false;
293 to_fill.description = render_ptr(data_pointer);
296 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
297 + astring("\\InternalName")), &data_pointer, &data_size))
298 total_success = false;
300 to_fill.internal_name = render_ptr(data_pointer);
303 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
304 + astring("\\LegalCopyright")), &data_pointer, &data_size))
305 total_success = false;
307 to_fill.copyright = render_ptr(data_pointer);
310 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
311 + astring("\\LegalTrademarks")), &data_pointer, &data_size))
312 total_success = false;
314 to_fill.trademarks = render_ptr(data_pointer);
316 // original file name.
317 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
318 + astring("\\OriginalFilename")), &data_pointer, &data_size))
319 total_success = false;
321 to_fill.original_name = render_ptr(data_pointer);
324 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
325 + astring("\\ProductName")), &data_pointer, &data_size))
326 total_success = false;
328 to_fill.product_name = render_ptr(data_pointer);
331 if (!VerQueryValue(version_info_found.access(), to_unicode_temp(root_key
332 + astring("\\ProductVersion")), &data_pointer, &data_size))
333 total_success = false;
335 to_fill.product_version = version::from_text(render_ptr(data_pointer));
337 // hmmm: chunks missing in version check.
340 return total_success;
343 void version_checker::complain_wrong_version(const astring &library_file_name,
344 const version &expected_version, const version &version_found) const
346 astring to_show("There has been a Version Mismatch: The module \"");
347 // use embedded module handle to retrieve name of dll or exe.
348 astring module_name = get_name(version::__global_module_handle());
349 if (!module_name) module_name = "Unknown";
350 to_show += module_name;
351 to_show += astring("\" cannot load. This is because the file \"");
352 to_show += library_file_name;
353 to_show += astring("\" was expected to have a version of [");
355 to_show += expected_version.flex_text_form(version::DOTS);
357 to_show += astring("] but it instead had a version of [");
358 to_show += version_found.flex_text_form(version::DOTS);
360 to_show += astring("]. ");
361 to_show += *_version_complaint;
363 #if defined(__UNIX__)
364 //|| defined(__GNU_WINDOWS__)
365 continuable_error("version checking", "failure", to_show.s());
366 #elif defined(__WIN32__)
367 MessageBox(0, to_unicode_temp(to_show),
368 to_unicode_temp("version_checking::failure"), MB_OK);
372 void version_checker::complain_cannot_load(const astring &lib_file) const
374 astring to_show("There has been a failure in Version Checking: The file \"");
376 to_show += astring("\" could not be loaded or found. ");
377 to_show += *_version_complaint;
378 continuable_error("version checking", "loading dll", to_show.s());