src/util-misc.c

   1 /*
   2     Copyright (C) 2006-2022 Ben Kibbey <bjk@luxsci.net>
   3
   4     This file is part of pwmd.
   5
   6     Pwmd is free software: you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License version 2 as
   8     published by the Free Software Foundation.
   9
  10     Pwmd is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with Pwmd.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18 #ifdef HAVE_CONFIG_H
  19 #include <config.h>
  20 #endif
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <errno.h>
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28 #include <sys/types.h>
  29 #include <sys/stat.h>
  30 #ifdef HAVE_FCNTL_H
  31 #include <fcntl.h>
  32 #endif
  33 #include <ctype.h>
  34 #include <pwd.h>
  35
  36 #include "pwmd-error.h"
  37 #include <gcrypt.h>
  38 #include "util-misc.h"
  39 #include "util-string.h"
  40 #include "mutex.h"
  41 #include "cache.h"
  42 #include "mem.h"
  43
  44 char *home_directory;
  45 void log_write (const char *fmt, ...);
  46
  47 int
  48 valid_filename (const char *filename)
  49 {
  50   const char *p;
  51
  52   if (!filename || !*filename)
  53     return 0;
  54
  55   if (filename[0] == '-' && filename[1] == 0)
  56     return 0;
  57
  58   for (p = filename; *p; p++)
  59     {
  60       if (*p == '/' || isspace (*p))
  61         return 0;
  62     }
  63
  64   return 1;
  65 }
  66
  67 /* If 'user' is null then lookup entry for 'uid'. Caller must free 'buf'. */
  68 struct passwd *
  69 get_pwd_struct (const char *user, uid_t uid, struct passwd *pw, char **buf,
  70                 gpg_error_t *rc)
  71 {
  72   struct passwd *result = NULL;
  73 #ifdef HAVE_GETPWNAM_R
  74   size_t len;
  75   int err = 0;
  76
  77   len = sysconf (_SC_GETPW_R_SIZE_MAX);
  78   if (len == -1)
  79     len = 16384;
  80
  81   *buf = xmalloc (len);
  82   if (!*buf)
  83     return NULL;
  84
  85   if (user)
  86     err = getpwnam_r (user, pw, *buf, len, &result);
  87   else
  88     err = getpwuid_r (uid, pw, *buf, len, &result);
  89
  90   if (!err && result)
  91     return result;
  92
  93   xfree (*buf);
  94   *buf = NULL;
  95   errno = err;
  96   *rc = gpg_error_from_errno (err);
  97   return NULL;
  98 #else
  99   if (buf)
 100     *buf = NULL;
 101
 102   errno = 0;
 103   if (user)
 104     result = getpwnam (user);
 105   else
 106     result = getpwuid (uid);
 107
 108   if (!result)
 109     *rc = gpg_error_from_syserror ();
 110
 111   return result;
 112 #endif
 113 }
 114
 115 static char *
 116 get_pwd_entry(uid_t uid, int which)
 117 {
 118   gpg_error_t rc;
 119   char *buf;
 120   struct passwd pw;
 121   struct passwd *result = get_pwd_struct (NULL, uid, &pw, &buf, &rc);
 122   char *value = NULL;
 123
 124   if (!result)
 125     return NULL;
 126
 127   if (result)
 128     {
 129       if (!which)
 130         value = str_dup (result->pw_dir);
 131       else
 132         value = str_dup (result->pw_name);
 133     }
 134
 135   xfree (buf);
 136   return value;
 137 }
 138
 139 char *
 140 get_username (uid_t uid)
 141 {
 142   return get_pwd_entry (uid, 1);
 143 }
 144
 145 char *
 146 get_home_dir ()
 147 {
 148   if (home_directory)
 149     return home_directory;
 150
 151   home_directory = get_pwd_entry (getuid(), 0);
 152   return home_directory;
 153 }
 154
 155 char *
 156 expand_homedir (char *str)
 157 {
 158   char *p = str;
 159
 160   if (*p++ == '~')
 161     {
 162       char *dir = get_pwd_entry(getuid(), 0);
 163       char *s;
 164
 165       if (!dir)
 166         return NULL;
 167
 168       s = str_asprintf ("%s%s", dir, p);
 169       xfree (dir);
 170       return s;
 171     }
 172
 173   return str_dup (str);
 174 }
 175
 176 /* The 'more' parameter lets the calling command process remaining
 177  * non-option arguments. */
 178 gpg_error_t
 179 parse_options (char **line, struct argv_s * args[], void *data, int more)
 180 {
 181   char *p = *line;
 182   gpg_error_t rc = 0;
 183
 184   for (; p && *p; p++)
 185     {
 186       while (*p == ' ')
 187         p++;
 188
 189       if (!*p)
 190         break;
 191
 192       if (*p == '-' && *(p + 1) == '-')
 193         {
 194           p += 2;
 195           char opt[255] = { 0 }, value[255] =
 196           {
 197           0};
 198           char *tp;
 199           unsigned len;
 200
 201           if (!*p || *p == ' ')
 202             {
 203               if (*p)
 204                 p++;
 205
 206               break;
 207             }
 208
 209           for (tp = opt, len = 0; *p; p++, len++)
 210             {
 211               if (len + 1 == 255)
 212                 return GPG_ERR_LINE_TOO_LONG;
 213
 214               if (*p == ' ' || *p == '=')
 215                 {
 216                   *tp = 0;
 217
 218                   if (*p == '=')
 219                     {
 220                       int inquote = 0;
 221
 222                       p++;
 223
 224                       for (tp = value, len = 0; *p; p++, len++)
 225                         {
 226                           if (len + 1 == 255)
 227                             return GPG_ERR_LINE_TOO_LONG;
 228
 229                           if (*p == '\"')
 230                             {
 231                               inquote = !inquote;
 232                               continue;
 233                             }
 234                           else if (*p == ' ' && !inquote)
 235                             break;
 236
 237                           *tp++ = *p;
 238                         }
 239
 240                       *tp = 0;
 241                     }
 242
 243                   break;
 244                 }
 245
 246               *tp++ = *p;
 247             }
 248
 249           *tp = 0;
 250           int match = 0;
 251
 252           for (int i = 0; args[i]; i++)
 253             {
 254               if (!strcmp (args[i]->opt, opt))
 255                 {
 256                   log_write2 ("param: name='%s' value='%s'", opt, value);
 257                   if (args[i]->type == OPTION_TYPE_NOARG && *value)
 258                     return GPG_ERR_SYNTAX;
 259                   else if (args[i]->type == OPTION_TYPE_ARG && !*value)
 260                     return GPG_ERR_SYNTAX;
 261
 262                   if (args[i]->func)
 263                     {
 264                       rc = args[i]->func (data, value);
 265                       if (rc)
 266                         return rc;
 267                     }
 268
 269                   match = 1;
 270                   break;
 271                 }
 272             }
 273
 274           if (!match)
 275             return GPG_ERR_UNKNOWN_OPTION;
 276
 277           if (!*p)
 278             break;
 279
 280           continue;
 281         }
 282
 283       if (*(p+1) && !more)
 284         return GPG_ERR_SYNTAX;
 285
 286       break;
 287     }
 288
 289   *line = p;
 290   return rc;
 291 }
 292
 293 char *
 294 bin2hex (const unsigned char *data, size_t len)
 295 {
 296   size_t size = len * 2 + 1;
 297   char buf[size];
 298   size_t n;
 299
 300   buf[0] = 0;
 301
 302   for (n = 0; n < len; n++)
 303     {
 304       char c[3];
 305
 306       sprintf (c, "%02X", data[n]);
 307       strcat (buf, c);
 308     }
 309
 310   return str_dup (buf);
 311 }
 312
 313 static char *
 314 html_escape (const char *line, size_t len, int space)
 315 {
 316   struct string_s *string = string_new ("");
 317   size_t n;
 318   char *tmp;
 319
 320   if (!string)
 321     return NULL;
 322
 323   for (n = 0; n < len; n++)
 324     {
 325       switch (line[n])
 326         {
 327         case '<':
 328           string = string_append (string, "&lt;");
 329           break;
 330         case '>':
 331           string = string_append (string, "&gt;");
 332           break;
 333         case ' ':
 334           if (space)
 335             {
 336               string = string_append (string, "%20");
 337               break;
 338             }
 339         default:
 340           string = string_append_printf (string, "%c", line[n]);
 341           break;
 342         }
 343     }
 344
 345   tmp = string->str;
 346   string_free (string, 0);
 347   return tmp;
 348 }
 349
 350 static char *
 351 strip_texi_html (const char *line)
 352 {
 353   size_t len;
 354   const char *p;
 355   char *tmp;
 356   struct string_s *string = string_new ("<html><body>");
 357
 358   if (!string)
 359     return NULL;
 360
 361   /* The command usage text. */
 362   p = strchr (line, '\n');
 363   if (p)
 364     {
 365       len = strlen (line)-strlen(p);
 366       tmp = html_escape (line, len, 0);
 367       string = string_append_printf (string, "<b>%s</b><p>", tmp);
 368       xfree (tmp);
 369       p++;
 370     }
 371   else
 372     p = line;
 373
 374   for (; p && *p; p++)
 375     {
 376       int non_anchor = 1;
 377       int var = 0;
 378       int code = 0;
 379       int emph = 0;
 380       int cite = 0;
 381
 382       if (*p == '@' && *(p + 1) != '@')
 383         {
 384           p++;
 385
 386           if (!strncasecmp (p, "end ", 4))
 387             {
 388               p += 4;
 389               if (!strncasecmp (p, "table", 5))
 390                 {
 391                   string = string_append (string, "</p>");
 392                 }
 393               else if (!strncasecmp (p, "example", 7))
 394                 {
 395                   string = string_append (string, "</code>");
 396                 }
 397
 398               while (*p++ != '\n');
 399               p--;
 400               continue;
 401             }
 402           else if (!strncasecmp (p, "table ", 6))
 403             {
 404               while (*p++ != '\n');
 405               p--;
 406               continue;
 407             }
 408           else if (!strncasecmp (p, "example", 7))
 409             {
 410               string = string_append (string, "<code>");
 411               while (*p++ != '\n');
 412               p--;
 413               continue;
 414             }
 415           else if (!strncasecmp (p, "sp ", 3))
 416             {
 417               while (*p++ != '\n');
 418               p--;
 419               string = string_append (string, "<p>");
 420               continue;
 421             }
 422           else if (!strncasecmp (p, "item ", 5))
 423             {
 424               p += 5;
 425               string = string_append (string, "<p><b>");
 426               tmp = strchr (p, '\n');
 427               len = strlen (p) - strlen (tmp);
 428               while (len--)
 429                 {
 430                   if (*p == '<')
 431                     {
 432                       string = string_append (string, "&lt;");
 433                       p++;
 434                     }
 435                   else if (*p == '>')
 436                     {
 437                       string = string_append (string, "&gt;");
 438                       p++;
 439                     }
 440                   else
 441                     string = string_append_printf (string, "%c", *p++);
 442                 }
 443
 444               string = string_append (string, "</b><br/>");
 445               continue;
 446             }
 447           else if (!strncasecmp (p, "pxref", 5)
 448                    || !strncasecmp (p, "npxref", 6))
 449             {
 450               int n = 0;
 451
 452               if (!strncasecmp (p, "npxref", 6))
 453                 n++;
 454
 455               p += n ? 7 : 6;
 456               non_anchor = 0;
 457               string = string_append_printf (string, "%s<a href=\"",
 458                                              n ? "" : "see ");
 459               goto close;
 460             }
 461           else if (!strncasecmp (p, "xref", 4))
 462             {
 463               p += 5;
 464               non_anchor = 0;
 465               string = string_append (string, "See <a href=\"");
 466               goto close;
 467             }
 468           else if (!strncasecmp (p, "url", 3))
 469             {
 470               p += 4;
 471               non_anchor = 0;
 472               string = string_append (string, "<a href=\"");
 473               goto close;
 474             }
 475           else if (!strncasecmp (p, "key", 3))
 476             {
 477               p += 4;
 478               goto close;
 479             }
 480           else if (!strncasecmp (p, "file", 4))
 481             {
 482               p += 5;
 483               var = 1;
 484               string = string_append (string, "<var>");
 485               goto close;
 486             }
 487           else if (!strncasecmp (p, "var", 3))
 488             {
 489               p += 4;
 490               var = 1;
 491               string = string_append (string, "<var>");
 492               goto close;
 493             }
 494           else if (!strncasecmp (p, "option", 6))
 495             {
 496               p += 7;
 497               var = 1;
 498               string = string_append (string, "<var>");
 499               goto close;
 500             }
 501           else if (!strncasecmp (p, "code", 4))
 502             {
 503               p += 5;
 504               code = 1;
 505               string = string_append (string, "<b>");
 506               goto close;
 507             }
 508           else if (!strncasecmp (p, "emph", 4))
 509             {
 510               p += 5;
 511               emph = 1;
 512               string = string_append (string, "<em>");
 513               goto close;
 514             }
 515           else if (!strncasecmp (p, "command", 7))
 516             {
 517               p += 8;
 518               emph = 1;
 519               string = string_append (string, "<em>");
 520               goto close;
 521             }
 522           else if (!strncasecmp (p, "cite", 4))
 523             {
 524               p += 5;
 525               cite = 1;
 526               string = string_append (string, "<cite>");
 527               goto close;
 528             }
 529           else if (!strncasecmp (p, "abbr", 4))
 530             {
 531               p += 5;
 532               emph = 1;
 533               string = string_append (string, "<em>");
 534               goto close;
 535             }
 536           else if (!strncasecmp (p, "*", 1))
 537             {
 538               string = string_append (string, "<br/>");
 539               continue;
 540             }
 541
 542           while (*p && *p != '{')
 543             {
 544               if (*++p == '*')
 545                 {
 546                   p++;
 547                   goto append;
 548                 }
 549             }
 550
 551         close:
 552           if (*p)
 553             {
 554               char buf [255];
 555
 556               tmp = strchr (p, '}');
 557               len = strlen (p) - strlen (tmp);
 558               tmp = buf;
 559               while (len--)
 560                 *tmp++ = *p++;
 561
 562               *tmp = 0;
 563
 564               if (*p)
 565                 p++;
 566
 567               if (!non_anchor)
 568                 {
 569                   tmp = html_escape (buf, strlen (buf), 1);
 570                   string = string_append_printf (string, "%s\">%s</a>", tmp, buf);
 571                   xfree (tmp);
 572                 }
 573               else
 574                 string = string_append (string, buf);
 575
 576               if (var)
 577                 string = string_append (string, "</var>");
 578               else if (code)
 579                 string = string_append (string, "</b>");
 580               else if (emph)
 581                 string = string_append (string, "</em>");
 582               else if (cite)
 583                 string = string_append (string, "</cite>");
 584             }
 585         }
 586       else if (*p == '@' && *(p + 1) == '@')
 587         p++;
 588
 589     append:
 590       string = string_append_printf (string, "%c", *p);
 591
 592       if (!*p)
 593         break;
 594     }
 595
 596   string = string_append (string, "</body></html>");
 597   tmp = string->str;
 598   string_free (string, 0);
 599   return tmp;
 600 }
 601
 602 static char *
 603 strip_texi (const char *str, int html)
 604 {
 605   const char *p;
 606   char *s;
 607   int c = 0;
 608
 609   if (html)
 610     return strip_texi_html (str);
 611
 612   s = str_dup (str);
 613   if (!s)
 614     return NULL;
 615
 616   for (p = str; *p; p++)
 617     {
 618       if (*p == '@' && *(p + 1) != '@')
 619         {
 620           p++;
 621
 622           if (!strncasecmp (p, "table", 5)
 623               || !strncasecmp (p, "end ", 4))
 624             {
 625               while (*p++ != '\n');
 626               p--;
 627               continue;
 628             }
 629           else if (!strncasecmp (p, "example", 7)
 630                    || !strncasecmp (p, "end ", 4))
 631             {
 632               while (*p++ != '\n');
 633               p--;
 634               continue;
 635             }
 636           else if (!strncasecmp (p, "sp ", 3))
 637             {
 638               while (*p++ != '\n');
 639               p--;
 640               continue;
 641             }
 642           else if (!strncasecmp (p, "item", 4))
 643             {
 644               p += 5;
 645               while (*p && *p != '\n')
 646                 s[c++] = *p++;
 647
 648               s[c++] = '\n';
 649               continue;
 650             }
 651           else if (!strncasecmp (p, "pxref", 5))
 652             {
 653               p += 5;
 654               strcat (s, "see ");
 655               c = strlen (s);
 656               goto close;
 657             }
 658           else if (!strncasecmp (p, "xref", 4))
 659             {
 660               p += 4;
 661               strcat (s, "See ");
 662               c = strlen (s);
 663               goto close;
 664             }
 665           else if (!strncasecmp (p, "*", 1))
 666             {
 667               s[c++] = '\n';
 668               s[c] = 0;
 669               continue;
 670             }
 671
 672           while (*p && *p != '{')
 673             {
 674               if (*++p == '*')
 675                 {
 676                   p++;
 677                   goto append;
 678                 }
 679             }
 680
 681         close:
 682           if (*p)
 683             {
 684               p++;
 685               s[c++] = '`';
 686               while (*p && *p != '}')
 687                 s[c++] = *p++;
 688
 689               if (*p)
 690                 p++;
 691
 692               s[c++] = '\'';
 693               s[c] = 0;
 694             }
 695         }
 696       else if (*p == '@' && *(p + 1) == '@')
 697         p++;
 698
 699     append:
 700       if (*p)
 701         s[c++] = *p;
 702
 703       s[c] = 0;
 704     }
 705
 706   s[c] = 0;
 707   return s;
 708 }
 709
 710
 711 char *
 712 strip_texi_and_wrap (const char *str, int html)
 713 {
 714   char *tmp = strip_texi (str, html);
 715   char *help = xcalloc (1, strlen (tmp) * 2 + 1);
 716   char *p, *ph;
 717   int i;
 718
 719   for (p = tmp, ph = help, i = 0; *p; p++, i++)
 720     {
 721       if (i == 78 || *p == '\n')
 722         {
 723           if (!isspace (*p))
 724             {
 725               char *t = ph;
 726               int n = 0;
 727
 728               while (*(--t) != ' ')
 729                 n++;
 730
 731               *t++ = '\n';
 732               i = -1;
 733               p -= n;
 734               while (n--)
 735                 {
 736                   *t++ = *p++;
 737                   i++;
 738                 }
 739             }
 740           else
 741             {
 742               *ph++ = '\n';
 743               i = -1;
 744               while (*p != '\n' && *p == ' ')
 745                 p++;
 746             }
 747         }
 748
 749       if (*p == '\n')
 750         continue;
 751       *ph++ = *p;
 752     }
 753
 754   *ph = 0;
 755   xfree (tmp);
 756   return help;
 757 }
 758
 759 void
 760 free_key (void *data)
 761 {
 762   xfree (data);
 763 }
 764
 765 gpg_error_t
 766 create_thread (void *(*cb) (void *), void *data,
 767                pthread_t * tid, int detached)
 768 {
 769   pthread_attr_t attr;
 770   int n;
 771
 772   pthread_attr_init (&attr);
 773
 774   if (detached)
 775     pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
 776
 777   n = pthread_create (tid, &attr, cb, data);
 778   pthread_attr_destroy (&attr);
 779   return gpg_error_from_errno (n);
 780 }
 781
 782 void
 783 release_mutex_cb (void *arg)
 784 {
 785   pthread_mutex_t *m = (pthread_mutex_t *) arg;
 786
 787   MUTEX_UNLOCK (m);
 788 }
 789
 790 void
 791 close_fd_cb (void *arg)
 792 {
 793   int fd = *(int *)arg;
 794
 795   if (fd != -1)
 796     close (fd);
 797 }
 798
 799 gpg_error_t
 800 get_checksum_memory (void *data, size_t size, unsigned char **r_crc,
 801                      size_t *r_crclen)
 802 {
 803   size_t len = gcry_md_get_algo_dlen (GCRY_MD_CRC32);
 804   unsigned char *crc = xmalloc (len);
 805
 806   *r_crc = NULL;
 807   *r_crclen = 0;
 808
 809   if (!crc)
 810     return GPG_ERR_ENOMEM;
 811
 812   gcry_md_hash_buffer (GCRY_MD_CRC32, crc, data, size);
 813   *r_crc = crc;
 814   *r_crclen = len;
 815   return 0;
 816 }
 817
 818 /* The advisory lock should be obtained before calling this function. */
 819 gpg_error_t
 820 get_checksum (const char *filename, unsigned char **r_crc, size_t * r_crclen)
 821 {
 822   int fd = -1;
 823   unsigned char *buf;
 824   gpg_error_t rc;
 825   struct stat st;
 826
 827   rc = open_check_file (filename, &fd, &st, 1);
 828   if (rc)
 829     return rc;
 830
 831   pthread_cleanup_push (close_fd_cb, &fd);
 832   buf = xmalloc (st.st_size);
 833   if (buf)
 834     {
 835       pthread_cleanup_push (xfree, buf);
 836
 837       size_t len = read (fd, buf, st.st_size);
 838       if (len == st.st_size)
 839         {
 840           if (buf)
 841             rc = get_checksum_memory (buf, st.st_size, r_crc, r_crclen);
 842           else
 843             rc = GPG_ERR_ENOMEM;
 844         }
 845       else
 846         rc = GPG_ERR_TOO_SHORT;
 847
 848       pthread_cleanup_pop (1);
 849     }
 850   else
 851     rc = GPG_ERR_ENOMEM;
 852
 853   pthread_cleanup_pop (1);
 854   return rc;
 855 }
 856
 857 wchar_t *str_to_wchar (const char *str)
 858 {
 859     wchar_t *wc;
 860     mbstate_t ps;
 861     const char *p = str;
 862     size_t len;
 863
 864     memset (&ps, 0, sizeof(mbstate_t));
 865     len = mbsrtowcs (NULL, &p, 0, &ps);
 866     if (len == -1)
 867       return NULL;
 868
 869     wc = xcalloc (len+1, sizeof(wchar_t));
 870     if (!wc)
 871       return NULL;
 872
 873     p = str;
 874     memset (&ps, 0, sizeof(mbstate_t));
 875     len = mbsrtowcs (wc, &p, len, &ps);
 876     if (len == -1)
 877       {
 878         xfree (wc);
 879         return NULL;
 880       }
 881
 882     return wc;
 883 }
 884
 885 char *
 886 gnupg_escape (const char *str)
 887 {
 888   if (!str || !*str)
 889     return NULL;
 890
 891   char *buf = xmalloc (strlen(str)*4+1), *b = buf;
 892   const char *p;
 893
 894   if (!buf)
 895     return NULL;
 896
 897   for (p = str; p && *p; p++)
 898     {
 899       if (*p == ':')
 900         {
 901           *b++ = '\\';
 902           *b++ = 'x';
 903           *b++ = '3';
 904           *b++ = 'a';
 905           continue;
 906         }
 907       else if (*p == '\\')
 908         {
 909           *b++ = '\\';
 910           *b++ = 'x';
 911           *b++ = '5';
 912           *b++ = 'c';
 913           continue;
 914         }
 915
 916       *b++ = *p;
 917     }
 918
 919   *b = 0;
 920   return buf;
 921 }
 922
 923 /* From Beej's Guide to Network Programming. It's a good tutorial. */
 924 void *
 925 get_in_addr (struct sockaddr *sa)
 926 {
 927   if (sa->sa_family == AF_INET)
 928     return &(((struct sockaddr_in *) sa)->sin_addr);
 929
 930   return &(((struct sockaddr_in6 *) sa)->sin6_addr);
 931 }
 932
 933 gpg_error_t
 934 open_check_file (const char *filename, int *r_fd, struct stat *r_st, int reg)
 935 {
 936   int fd;
 937   gpg_error_t rc = 0;
 938
 939   if (r_st)
 940     memset (r_st, 9, sizeof (struct stat));
 941
 942   if (reg)
 943     {
 944       struct stat st;
 945
 946       if (lstat (filename, &st) == -1)
 947         return gpg_err_code (gpg_error_from_syserror ());
 948
 949       if (!S_ISREG (st.st_mode))
 950         return GPG_ERR_ENODEV;
 951
 952       if (r_st)
 953         memcpy (r_st, &st, sizeof (struct stat));
 954     }
 955
 956   if (r_fd)
 957     {
 958       fd = open (filename, O_RDONLY);
 959       if (fd == -1)
 960         return gpg_err_code (gpg_error_from_syserror ());
 961
 962       if (r_st && fstat (fd, r_st) == -1)
 963         {
 964           rc = gpg_err_code (gpg_error_from_syserror ());
 965           close (fd);
 966           return rc;
 967         }
 968
 969       *r_fd = fd;
 970     }
 971
 972   return 0;
 973 }