27d720b3c663b24844584ca2b62f7f7ebca7e256
[gpgme.git] / gpgme / version.c
1 /* version.c -  version check
2  *      Copyright (C) 2000 Werner Koch (dd9jn)
3  *      Copyright (C) 2001 g10 Code GmbH
4  *
5  * This file is part of GPGME.
6  *
7  * GPGME is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * GPGME is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <ctype.h>
27
28 #include "gpgme.h"
29 #include "context.h"
30 #include "rungpg.h"
31 #include "sema.h"
32 #include "util.h"
33 #include "key.h" /* for key_cache_init */
34 #include "io.h"
35
36 static const char *get_engine_info (void);
37
38 static void
39 do_subsystem_inits (void)
40 {
41     static int done = 0;
42
43     if (done)
44         return;
45     _gpgme_sema_subsystem_init ();
46     _gpgme_key_cache_init ();
47 }
48
49 static const char*
50 parse_version_number ( const char *s, int *number )
51 {
52     int val = 0;
53
54     if ( *s == '0' && isdigit(s[1]) )
55         return NULL; /* leading zeros are not allowed */
56     for ( ; isdigit(*s); s++ ) {
57         val *= 10;
58         val += *s - '0';
59     }
60     *number = val;
61     return val < 0? NULL : s;
62 }
63
64 static const char *
65 parse_version_string( const char *s, int *major, int *minor, int *micro )
66 {
67     s = parse_version_number ( s, major );
68     if ( !s || *s != '.' )
69         return NULL;
70     s++;
71     s = parse_version_number ( s, minor );
72     if ( !s || *s != '.' )
73         return NULL;
74     s++;
75     s = parse_version_number ( s, micro );
76     if ( !s )
77         return NULL;
78     return s; /* patchlevel */
79 }
80
81 const char *
82 _gpgme_compare_versions (const char *my_version,
83                          const char *req_version)
84 {
85   int my_major, my_minor, my_micro;
86   int rq_major, rq_minor, rq_micro;
87   const char *my_plvl, *rq_plvl;
88
89   if (!req_version)
90     return my_version;
91   if (!my_version)
92     return NULL;
93
94   my_plvl = parse_version_string (my_version, &my_major, &my_minor, &my_micro);
95   if (!my_plvl)
96     return NULL;        /* Very strange: our own version is bogus.  */
97   rq_plvl = parse_version_string(req_version,
98                                  &rq_major, &rq_minor, &rq_micro);
99   if (!rq_plvl)
100     return NULL;        /* Requested version string is invalid.  */
101
102   if (my_major > rq_major
103         || (my_major == rq_major && my_minor > rq_minor)
104       || (my_major == rq_major && my_minor == rq_minor 
105           && my_micro > rq_micro)
106       || (my_major == rq_major && my_minor == rq_minor
107           && my_micro == rq_micro
108           && strcmp( my_plvl, rq_plvl ) >= 0))
109     {
110       return my_version;
111     }
112   return NULL;
113 }
114
115 /**
116  * gpgme_check_version:
117  * @req_version: A string with a version
118  * 
119  * Check that the the version of the library is at minimum the requested one
120  * and return the version string; return NULL if the condition is not
121  * met.  If a NULL is passed to this function, no check is done and
122  * the version string is simply returned.  It is a pretty good idea to
123  * run this function as soon as possible, because it also intializes 
124  * some subsystems.  In a multithreaded environment if should be called
125  * before the first thread is created.
126  * 
127  * Return value: The version string or NULL
128  **/
129 const char *
130 gpgme_check_version (const char *req_version)
131 {
132   do_subsystem_inits ();
133   return _gpgme_compare_versions (VERSION, req_version);
134 }
135
136 /**
137  * gpgme_get_engine_info:
138  *  
139  * Return information about the underlying crypto engines.  This is an
140  * XML string with various information.  A string is always returned
141  * even if the crypto engines is not installed; in this case a XML
142  * string with some error information is returned.
143  * 
144  * Return value: A XML string with information about the crypto
145  * engines.
146  **/
147 const char *
148 gpgme_get_engine_info ()
149 {
150   static const char *engine_info;
151   const char *openpgp_info = _gpgme_engine_get_info (GPGME_PROTOCOL_OpenPGP);
152   const char *cms_info = _gpgme_engine_get_info (GPGME_PROTOCOL_CMS);
153   char *info;
154
155   /* FIXME: Make sure that only one instance does run.  */
156   if (engine_info)
157     return engine_info;
158
159   if (!openpgp_info && !cms_info)
160     info = "<EngineInfo>\n</EngineInfo>\n";
161   else if (!openpgp_info || !cms_info)
162     {
163       const char *fmt = "<EngineInfo>\n"
164         "%s"
165         "</EngineInfo>\n";
166
167       info = xtrymalloc (strlen(fmt) + strlen(openpgp_info
168                                               ? openpgp_info : cms_info) + 1);
169       if (info)
170         sprintf (info, fmt, openpgp_info ? openpgp_info : cms_info);
171     }
172   else
173     {
174       const char *fmt = "<EngineInfo>\n"
175         "%s%s"
176         "</EngineInfo>\n";
177       info = xtrymalloc (strlen(fmt) + strlen(openpgp_info)
178                          + strlen (cms_info) + 1);
179       if (info)
180         sprintf (info, fmt, openpgp_info, cms_info);
181     }
182   if (!info)
183     info = "<EngineInfo>\n"
184       "  <error>Out of core</error>\n"
185       "</EngineInfo>\n";
186   engine_info = info;
187   return engine_info;
188 }
189
190 /**
191  * gpgme_check_engine:
192  * 
193  * Check whether the installed crypto engine for the OpenPGP protocol
194  * matches the requirement of GPGME.  This function is deprecated,
195  * instead use gpgme_engine_get_info() with the specific protocol you
196  * need.
197  *
198  * Return value: 0 or an error code.
199  **/
200 GpgmeError
201 gpgme_check_engine ()
202 {
203   return gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
204 }
205
206 \f
207 #define LINELENGTH 80
208
209 char *
210 _gpgme_get_program_version (const char *const path)
211 {
212   char line[LINELENGTH] = "";
213   int linelen = 0;
214   char *mark = NULL;
215   int rp[2];
216   pid_t pid;
217   int nread;
218   char *argv[] = {(char *) path, "--version", 0};
219   struct spawn_fd_item_s pfd[] = { {0, -1}, {-1, -1} };
220   struct spawn_fd_item_s cfd[] = { {-1, 1 /* STDOUT_FILENO */}, {-1, -1} };
221   int status, signal;
222
223   if (!path)
224     return NULL;
225
226   if (_gpgme_io_pipe (rp, 1) < 0)
227     return NULL;
228
229   pfd[0].fd = rp[1];
230   cfd[0].fd = rp[1];
231
232   pid = _gpgme_io_spawn (path, argv, cfd, pfd);
233   if (pid < 0)
234     {
235       _gpgme_io_close (rp[0]);
236       _gpgme_io_close (rp[1]);
237       return NULL;
238     }
239
240   do
241     {
242       nread = _gpgme_io_read (rp[0], &line[linelen], LINELENGTH - linelen - 1);
243       if (nread > 0)
244         {
245           line[linelen + nread] = '\0';
246           mark = strchr (&line[linelen], '\n');
247           if (mark)
248             {
249               *mark = '\0';
250               break;
251             }
252           linelen += nread;
253         }
254     }
255   while (nread > 0 && linelen < LINELENGTH - 1);
256
257   _gpgme_io_close (rp[0]);
258   _gpgme_io_waitpid (pid, 1, &status, &signal);
259
260   if (mark)
261     {
262       mark = strrchr (line, ' ');
263       if (!mark)
264         return NULL;
265       return xtrystrdup (mark + 1);
266     }
267
268   return NULL;
269 }