3aef4045814ea834a9dcc4a9d208b03f3c1e9655
[gpgme.git] / src / version.c
1 /* version.c - Version check routines.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008 g10 Code GmbH
4  
5    This file is part of GPGME.
6  
7    GPGME is free software; you can redistribute it and/or modify it
8    under the terms of the GNU Lesser General Public License as
9    published by the Free Software Foundation; either version 2.1 of
10    the License, or (at your option) any later version.
11    
12    GPGME is distributed in the hope that it will be useful, but
13    WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Lesser General Public License for more details.
16    
17    You should have received a copy of the GNU Lesser General Public
18    License along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20    02111-1307, USA.  */
21
22 #if HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25 #include <stdlib.h>
26 #include <string.h>
27 #include <limits.h>
28 #include <ctype.h>
29 #ifdef HAVE_W32_SYSTEM
30 #include <winsock2.h>
31 #endif
32
33 #include "gpgme.h"
34 #include "priv-io.h"
35 #include "debug.h"
36 #include "context.h"
37
38 /* For _gpgme_sema_subsystem_init and _gpgme_status_init.  */
39 #include "sema.h"
40 #include "util.h"
41
42 #ifdef HAVE_ASSUAN_H
43 #include "assuan.h"
44 #endif
45
46 #ifdef HAVE_W32_SYSTEM
47 #include "windows.h"
48 #endif
49
50 /* We implement this function, so we have to disable the overriding
51    macro.  */
52 #undef gpgme_check_version
53
54 \f
55 /* Bootstrap the subsystems needed for concurrent operation.  This
56    must be done once at startup.  We can not guarantee this using a
57    lock, though, because the semaphore subsystem needs to be
58    initialized itself before it can be used.  So we expect that the
59    user performs the necessary synchronization.  */
60 static void
61 do_subsystem_inits (void)
62 {
63   static int done = 0;
64
65   if (done)
66     return;
67
68 #ifdef HAVE_W32_SYSTEM
69   /* We need to make sure that the sockets are initialized.  */
70   {
71     WSADATA wsadat;
72     
73     WSAStartup (0x202, &wsadat);
74   }
75 #endif
76
77   _gpgme_sema_subsystem_init ();
78   _gpgme_debug_subsystem_init ();
79   _gpgme_io_subsystem_init ();
80   _gpgme_status_init ();
81
82   done = 1;
83 }
84
85
86 /* Read the next number in the version string STR and return it in
87    *NUMBER.  Return a pointer to the tail of STR after parsing, or
88    *NULL if the version string was invalid.  */
89 static const char *
90 parse_version_number (const char *str, int *number)
91 {
92 #define MAXVAL ((INT_MAX - 10) / 10)
93   int val = 0;
94
95   /* Leading zeros are not allowed.  */
96   if (*str == '0' && isdigit(str[1]))
97     return NULL;
98
99   while (isdigit (*str) && val <= MAXVAL)
100     {
101       val *= 10;
102       val += *(str++) - '0';
103     }
104   *number = val;
105   return val > MAXVAL ? NULL : str;
106 }
107
108
109 /* Parse the version string STR in the format MAJOR.MINOR.MICRO (for
110    example, 9.3.2) and return the components in MAJOR, MINOR and MICRO
111    as integers.  The function returns the tail of the string that
112    follows the version number.  This might be te empty string if there
113    is nothing following the version number, or a patchlevel.  The
114    function returns NULL if the version string is not valid.  */
115 static const char *
116 parse_version_string (const char *str, int *major, int *minor, int *micro)
117 {
118   str = parse_version_number (str, major);
119   if (!str || *str != '.')
120     return NULL;
121   str++;
122
123   str = parse_version_number (str, minor);
124   if (!str || *str != '.')
125     return NULL;
126   str++;
127
128   str = parse_version_number (str, micro);
129   if (!str)
130     return NULL;
131
132   /* A patchlevel might follow.  */
133   return str;
134 }
135
136
137 /* Return true if MY_VERSION is at least REQ_VERSION, and false
138    otherwise.  */
139 int
140 _gpgme_compare_versions (const char *my_version,
141                          const char *rq_version)
142 {
143   int my_major, my_minor, my_micro;
144   int rq_major, rq_minor, rq_micro;
145   const char *my_plvl, *rq_plvl;
146
147   if (!rq_version)
148     return 1;
149   if (!my_version)
150     return 0;
151
152   my_plvl = parse_version_string (my_version, &my_major, &my_minor, &my_micro);
153   if (!my_plvl)
154     return 0;
155
156   rq_plvl = parse_version_string (rq_version, &rq_major, &rq_minor, &rq_micro);
157   if (!rq_plvl)
158     return 0;
159
160   if (my_major > rq_major
161       || (my_major == rq_major && my_minor > rq_minor)
162       || (my_major == rq_major && my_minor == rq_minor 
163           && my_micro > rq_micro)
164       || (my_major == rq_major && my_minor == rq_minor
165           && my_micro == rq_micro && strcmp (my_plvl, rq_plvl) >= 0))
166     return 1;
167
168   return 0;
169 }
170
171
172 /* Check that the the version of the library is at minimum the
173    requested one and return the version string; return NULL if the
174    condition is not met.  If a NULL is passed to this function, no
175    check is done and the version string is simply returned.
176
177    This function must be run once at startup, as it also initializes
178    some subsystems.  Its invocation must be synchronized against
179    calling any of the other functions in a multi-threaded
180    environments.  */
181 const char *
182 gpgme_check_version (const char *req_version)
183 {
184   char *result;
185   do_subsystem_inits ();
186
187   /* Catch-22: We need to get at least the debug subsystem ready
188      before using the trace facility.  If we won't the trace would
189      automagically initialize the debug system with out the locks
190      being initialized and missing the assuan log level setting. */
191   TRACE2 (DEBUG_INIT, "gpgme_check_version", 0,
192           "req_version=%s, VERSION=%s",
193           req_version? req_version:"(null)", VERSION);
194  
195   result = _gpgme_compare_versions (VERSION, req_version) ? VERSION : NULL;
196   if (result != NULL)
197     _gpgme_selftest = 0;
198
199   return result;
200 }
201
202 /* Check the version and also at runtime if the struct layout of the
203    library matches the one of the user.  This is particular useful for
204    Windows targets (-mms-bitfields).  */
205 const char *
206 gpgme_check_version_internal (const char *req_version,
207                               size_t offset_sig_validity)
208 {
209   const char *result;
210
211   result = gpgme_check_version (req_version);
212   if (result == NULL)
213     return result;
214
215   /* Catch-22, see above.  */
216   TRACE2 (DEBUG_INIT, "gpgme_check_version_internal", 0,
217           "req_version=%s, offset_sig_validity=%i",
218           req_version ? req_version : "(null)", offset_sig_validity);
219
220   if (offset_sig_validity != offsetof (struct _gpgme_signature, validity))
221     {
222       TRACE1 (DEBUG_INIT, "gpgme_check_version_internal", 0,
223               "offset_sig_validity mismatch: expected %i",
224               offsetof (struct _gpgme_signature, validity));
225       _gpgme_selftest = GPG_ERR_SELFTEST_FAILED;
226     }
227
228   return result;
229 }
230
231 \f
232 #define LINELENGTH 80
233
234 /* Extract the version string of a program from STRING.  The version
235    number is expected to be in GNU style format:
236    
237      foo 1.2.3
238      foo (bar system) 1.2.3
239      foo 1.2.3 cruft
240      foo (bar system) 1.2.3 cruft.
241
242   Spaces and tabs are skipped and used as delimiters, a term in
243   (nested) parenthesis before the version string is skipped, the
244   version string may consist of any non-space and non-tab characters
245   but needs to bstart with a digit.
246 */
247 static const char *
248 extract_version_string (const char *string, size_t *r_len)
249 {
250   const char *s;
251   int count, len;
252
253   for (s=string; *s; s++)
254     if (*s == ' ' || *s == '\t')
255         break;
256   while (*s == ' ' || *s == '\t')
257     s++;
258   if (*s == '(')
259     {
260       for (count=1, s++; count && *s; s++)
261         if (*s == '(')
262           count++;
263         else if (*s == ')')
264           count--;
265     }
266   /* For robustness we look for a digit.  */
267   while ( *s && !(*s >= '0' && *s <= '9') )
268     s++;
269   if (*s >= '0' && *s <= '9')
270     {
271       for (len=0; s[len]; len++)
272         if (s[len] == ' ' || s[len] == '\t')
273           break;
274     }
275   else
276     len = 0;
277
278   *r_len = len;
279   return s;
280 }
281
282
283 /* Retrieve the version number from the --version output of the
284    program FILE_NAME.  */
285 char *
286 _gpgme_get_program_version (const char *const file_name)
287 {
288   char line[LINELENGTH] = "";
289   int linelen = 0;
290   char *mark = NULL;
291   int rp[2];
292   int nread;
293   char *argv[] = {NULL /* file_name */, "--version", 0};
294   struct spawn_fd_item_s cfd[] = { {-1, 1 /* STDOUT_FILENO */, -1, 0},
295                                    {-1, -1} };
296   int status;
297
298   if (!file_name)
299     return NULL;
300   argv[0] = (char *) file_name;
301
302   if (_gpgme_io_pipe (rp, 1) < 0)
303     return NULL;
304
305   cfd[0].fd = rp[1];
306
307   status = _gpgme_io_spawn (file_name, argv, 0, cfd, NULL, NULL, NULL);
308   if (status < 0)
309     {
310       _gpgme_io_close (rp[0]);
311       _gpgme_io_close (rp[1]);
312       return NULL;
313     }
314
315   do
316     {
317       nread = _gpgme_io_read (rp[0], &line[linelen], LINELENGTH - linelen - 1);
318       if (nread > 0)
319         {
320           line[linelen + nread] = '\0';
321           mark = strchr (&line[linelen], '\n');
322           if (mark)
323             {
324               if (mark > &line[0] && *mark == '\r')
325                 mark--;
326               *mark = '\0';
327               break;
328             }
329           linelen += nread;
330         }
331     }
332   while (nread > 0 && linelen < LINELENGTH - 1);
333
334   _gpgme_io_close (rp[0]);
335
336   if (mark)
337     {
338       size_t len;
339       const char *s;
340
341       s = extract_version_string (line, &len);
342       if (!len)
343         return NULL;
344       mark = malloc (len + 1);
345       if (!mark)
346         return NULL;
347       memcpy (mark, s, len);
348       mark[len] = 0;
349       return mark;
350     }
351
352   return NULL;
353 }