locate/word_io.c

   1 /* word_io.c -- word oriented I/O
   2    Copyright (C) 2007 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  17    USA.
  18 */
  19
  20 #include <config.h>
  21
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <errno.h>
  25 #include <stdbool.h>            /* for bool */
  26 #include <assert.h>
  27
  28 #include "error.h"
  29 #include "quote.h"
  30 #include "quotearg.h"
  31 #include "locatedb.h"
  32
  33 #if ENABLE_NLS
  34 # include <libintl.h>
  35 # define _(Text) gettext (Text)
  36 #else
  37 # define _(Text) Text
  38 #define textdomain(Domain)
  39 #define bindtextdomain(Package, Directory)
  40 #endif
  41 #ifdef gettext_noop
  42 # define N_(String) gettext_noop (String)
  43 #else
  44 /* We used to use (String) instead of just String, but apparently ISO C
  45  * doesn't allow this (at least, that's what HP said when someone reported
  46  * this as a compiler bug).  This is HP case number 1205608192.  See
  47  * also http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11250 (which references
  48  * ANSI 3.5.7p14-15).  The Intel icc compiler also rejects constructs
  49  * like: static const char buf[] = ("string");
  50  */
  51 # define N_(String) String
  52 #endif
  53
  54
  55 /* Swap bytes in 32 bit value.  This code is taken from glibc-2.3.3. */
  56 #define bswap_32(x) \
  57      ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) | \
  58       (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
  59
  60 enum { WORDBYTES=4 };
  61
  62 static int
  63 decode_value(const unsigned char data[],
  64              int limit,
  65              GetwordEndianState *endian_state_flag,
  66              const char *filename)
  67 {
  68   int swapped;
  69   union
  70   {
  71     int ival;                   /* native representation */
  72     unsigned char data[WORDBYTES];
  73   } u;
  74   u.ival = 0;
  75   memcpy(&u.data, data, WORDBYTES);
  76   swapped = bswap_32(u.ival);   /* byteswapped */
  77
  78   if (*endian_state_flag == GetwordEndianStateInitial)
  79     {
  80       if (u.ival <= limit)
  81         {
  82           if (swapped > limit)
  83             {
  84               /* the native value is inside the limit and the
  85                * swapped value is not.  We take this as proof
  86                * that we should be using the ative byte order.
  87                */
  88               *endian_state_flag = GetwordEndianStateNative;
  89             }
  90           return u.ival;
  91         }
  92       else
  93         {
  94           if (swapped <= limit)
  95             {
  96               /* Aha, now we know we have to byte-swap. */
  97               error(0, 0,
  98                     _("Warning: locate database %s was "
  99                       "built with a different byte order"),
 100                     quotearg_n_style(0, locale_quoting_style, filename));
 101               *endian_state_flag = GetwordEndianStateSwab;
 102               return swapped;
 103             }
 104           else
 105             {
 106               /* u.ival > limit and swapped > limit.  For the moment, assume
 107                * native ordering.
 108                */
 109               return u.ival;
 110             }
 111         }
 112     }
 113   else
 114     {
 115       /* We already know the byte order. */
 116       if (*endian_state_flag == GetwordEndianStateSwab)
 117         return swapped;
 118       else
 119         return u.ival;
 120     }
 121 }
 122
 123
 124
 125 int
 126 getword (FILE *fp,
 127          const char *filename,
 128          size_t minvalue,
 129          size_t maxvalue,
 130          GetwordEndianState *endian_state_flag)
 131 {
 132   unsigned char data[4];
 133   size_t bytes_read;
 134
 135   clearerr(fp);
 136   bytes_read = fread(data, WORDBYTES, 1, fp);
 137   if (bytes_read != 1)
 138     {
 139       const char * quoted_name = quotearg_n_style(0, locale_quoting_style,
 140                                                   filename);
 141       /* Distinguish between a truncated database and an I/O error.
 142        * Either condition is fatal.
 143        */
 144       if (feof(fp))
 145         error(1, 0, _("Unexpected EOF in %s"), quoted_name);
 146       else
 147         error(1, errno, "error reading a word from %s", quoted_name);
 148     }
 149   else
 150     {
 151       return decode_value(data, maxvalue, endian_state_flag, filename);
 152     }
 153 }
 154
 155
 156 bool
 157 putword (FILE *fp, int word,
 158          GetwordEndianState endian_state_flag)
 159 {
 160   size_t items_written;
 161
 162   /* You must decide before calling this function which
 163    * endianness you want to use.
 164    */
 165   assert (endian_state_flag != GetwordEndianStateInitial);
 166   if (GetwordEndianStateSwab == endian_state_flag)
 167     {
 168       word = bswap_32(word);
 169     }
 170
 171   items_written = fwrite(&word, sizeof(word), 1, fp);
 172   if (1 == items_written)
 173     return true;
 174   else
 175     return false;
 176 }
 177