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
  37 static void
  38 do_subsystem_inits (void)
  39 {
  40   static int done = 0;
  41
  42   if (done)
  43     return;
  44   _gpgme_sema_subsystem_init ();
  45   _gpgme_key_cache_init ();
  46   done = 1;
  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     {
  58       val *= 10;
  59       val += *s - '0';
  60     }
  61   *number = val;
  62   return val < 0 ? NULL : s;
  63 }
  64
  65 static const char *
  66 parse_version_string (const char *s, int *major, int *minor, int *micro)
  67 {
  68   s = parse_version_number (s, major);
  69   if (!s || *s != '.')
  70     return NULL;
  71   s++;
  72   s = parse_version_number (s, minor);
  73   if (!s || *s != '.')
  74     return NULL;
  75   s++;
  76   s = parse_version_number (s, micro);
  77   if (!s)
  78     return NULL;
  79   return s;  /* Patchlevel.  */
  80 }
  81
  82 const char *
  83 _gpgme_compare_versions (const char *my_version,
  84                          const char *req_version)
  85 {
  86   int my_major, my_minor, my_micro;
  87   int rq_major, rq_minor, rq_micro;
  88   const char *my_plvl, *rq_plvl;
  89
  90   if (!req_version)
  91     return my_version;
  92   if (!my_version)
  93     return NULL;
  94
  95   my_plvl = parse_version_string (my_version, &my_major, &my_minor, &my_micro);
  96   if (!my_plvl)
  97     return NULL;        /* Very strange: our own version is bogus.  */
  98   rq_plvl = parse_version_string(req_version,
  99                                  &rq_major, &rq_minor, &rq_micro);
 100   if (!rq_plvl)
 101     return NULL;        /* Requested version string is invalid.  */
 102
 103   if (my_major > rq_major
 104         || (my_major == rq_major && my_minor > rq_minor)
 105       || (my_major == rq_major && my_minor == rq_minor
 106           && my_micro > rq_micro)
 107       || (my_major == rq_major && my_minor == rq_minor
 108           && my_micro == rq_micro
 109           && strcmp( my_plvl, rq_plvl ) >= 0))
 110     {
 111       return my_version;
 112     }
 113   return NULL;
 114 }
 115
 116 /**
 117  * gpgme_check_version:
 118  * @req_version: A string with a version
 119  *
 120  * Check that the the version of the library is at minimum the requested one
 121  * and return the version string; return NULL if the condition is not
 122  * met.  If a NULL is passed to this function, no check is done and
 123  * the version string is simply returned.  It is a pretty good idea to
 124  * run this function as soon as possible, because it also intializes
 125  * some subsystems.  In a multithreaded environment if should be called
 126  * before the first thread is created.
 127  *
 128  * Return value: The version string or NULL
 129  **/
 130 const char *
 131 gpgme_check_version (const char *req_version)
 132 {
 133   do_subsystem_inits ();
 134   return _gpgme_compare_versions (VERSION, req_version);
 135 }
 136
 137 /**
 138  * gpgme_get_engine_info:
 139  *
 140  * Return information about the underlying crypto engines.  This is an
 141  * XML string with various information.  A string is always returned
 142  * even if the crypto engines is not installed; in this case a XML
 143  * string with some error information is returned.
 144  *
 145  * Return value: A XML string with information about the crypto
 146  * engines.
 147  **/
 148 const char *
 149 gpgme_get_engine_info ()
 150 {
 151   static const char *engine_info;
 152   DEFINE_STATIC_LOCK (engine_info_lock);
 153
 154   LOCK (engine_info_lock);
 155   if (!engine_info)
 156     {
 157       const char *openpgp_info = _gpgme_engine_get_info (GPGME_PROTOCOL_OpenPGP);
 158       const char *cms_info = _gpgme_engine_get_info (GPGME_PROTOCOL_CMS);
 159       char *info;
 160
 161       if (!openpgp_info && !cms_info)
 162         info = "<EngineInfo>\n</EngineInfo>\n";
 163       else if (!openpgp_info || !cms_info)
 164         {
 165           const char *fmt = "<EngineInfo>\n"
 166             "%s"
 167             "</EngineInfo>\n";
 168
 169           info = xtrymalloc (strlen (fmt)
 170                              + strlen (openpgp_info
 171                                       ? openpgp_info : cms_info) + 1);
 172           if (info)
 173             sprintf (info, fmt, openpgp_info ? openpgp_info : cms_info);
 174         }
 175       else
 176         {
 177           const char *fmt = "<EngineInfo>\n"
 178             "%s%s"
 179             "</EngineInfo>\n";
 180           info = xtrymalloc (strlen (fmt) + strlen (openpgp_info)
 181                              + strlen (cms_info) + 1);
 182           if (info)
 183             sprintf (info, fmt, openpgp_info, cms_info);
 184         }
 185       if (!info)
 186         info = "<EngineInfo>\n"
 187           "  <error>Out of core</error>\n"
 188           "</EngineInfo>\n";
 189       engine_info = info;
 190     }
 191   UNLOCK (engine_info_lock);
 192   return engine_info;
 193 }
 194
 195
 196 /**
 197  * gpgme_check_engine:
 198  *
 199  * Check whether the installed crypto engine for the OpenPGP protocol
 200  * matches the requirement of GPGME.  This function is deprecated,
 201  * instead use gpgme_engine_get_info() with the specific protocol you
 202  * need.
 203  *
 204  * Return value: 0 or an error code.
 205  **/
 206 GpgmeError
 207 gpgme_check_engine ()
 208 {
 209   return gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
 210 }
 211
 212 \f
 213 #define LINELENGTH 80
 214
 215 char *
 216 _gpgme_get_program_version (const char *const path)
 217 {
 218   char line[LINELENGTH] = "";
 219   int linelen = 0;
 220   char *mark = NULL;
 221   int rp[2];
 222   int nread;
 223   char *argv[] = {NULL /* path */, "--version", 0};
 224   struct spawn_fd_item_s pfd[] = { {0, -1}, {-1, -1} };
 225   struct spawn_fd_item_s cfd[] = { {-1, 1 /* STDOUT_FILENO */}, {-1, -1} };
 226   int status;
 227
 228   if (!path)
 229     return NULL;
 230   argv[0] = (char *) path;
 231
 232   if (_gpgme_io_pipe (rp, 1) < 0)
 233     return NULL;
 234
 235   pfd[0].fd = rp[1];
 236   cfd[0].fd = rp[1];
 237
 238   status = _gpgme_io_spawn (path, argv, cfd, pfd);
 239   if (status < 0)
 240     {
 241       _gpgme_io_close (rp[0]);
 242       _gpgme_io_close (rp[1]);
 243       return NULL;
 244     }
 245
 246   do
 247     {
 248       nread = _gpgme_io_read (rp[0], &line[linelen], LINELENGTH - linelen - 1);
 249       if (nread > 0)
 250         {
 251           line[linelen + nread] = '\0';
 252           mark = strchr (&line[linelen], '\n');
 253           if (mark)
 254             {
 255               *mark = '\0';
 256               break;
 257             }
 258           linelen += nread;
 259         }
 260     }
 261   while (nread > 0 && linelen < LINELENGTH - 1);
 262
 263   _gpgme_io_close (rp[0]);
 264
 265   if (mark)
 266     {
 267       mark = strrchr (line, ' ');
 268       if (!mark)
 269         return NULL;
 270       return xtrystrdup (mark + 1);
 271     }
 272
 273   return NULL;
 274 }