locale/FreeBSD/rune.c

   1 /*-
   2  * Copyright (c) 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Paul Borman at Krystal Technologies.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36
  37 #if defined(LIBC_SCCS) && !defined(lint)
  38 static char sccsid[] = "@(#)rune.c      8.1 (Berkeley) 6/4/93";
  39 #endif /* LIBC_SCCS and not lint */
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD: src/lib/libc/locale/rune.c,v 1.12 2004/07/29 06:16:19 tjr Exp $");
  42
  43 #include "namespace.h"
  44 #include <arpa/inet.h>
  45 #include <errno.h>
  46 #include <runetype.h>
  47 #include <stdio.h>
  48 #include <string.h>
  49 #include <stdlib.h>
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52 #include "un-namespace.h"
  53
  54 _RuneLocale *
  55 _Read_RuneMagi(fp)
  56         FILE *fp;
  57 {
  58         char *data;
  59         void *lastp;
  60         _RuneLocale *rl;
  61         _RuneEntry *rr;
  62         struct stat sb;
  63         int x, saverr;
  64
  65         if (_fstat(fileno(fp), &sb) < 0)
  66                 return (NULL);
  67
  68         if (sb.st_size < sizeof(_RuneLocale)) {
  69                 errno = EFTYPE;
  70                 return (NULL);
  71         }
  72
  73         if ((data = malloc(sb.st_size)) == NULL)
  74                 return (NULL);
  75
  76         errno = 0;
  77         rewind(fp); /* Someone might have read the magic number once already */
  78         if (errno) {
  79                 saverr = errno;
  80                 free(data);
  81                 errno = saverr;
  82                 return (NULL);
  83         }
  84
  85         if (fread(data, sb.st_size, 1, fp) != 1) {
  86                 saverr = errno;
  87                 free(data);
  88                 errno = saverr;
  89                 return (NULL);
  90         }
  91
  92         rl = (_RuneLocale *)data;
  93         lastp = data + sb.st_size;
  94
  95         rl->__variable = rl + 1;
  96
  97         if (memcmp(rl->__magic, _RUNE_MAGIC_1, sizeof(rl->__magic))) {
  98                 free(data);
  99                 errno = EFTYPE;
 100                 return (NULL);
 101         }
 102
 103         rl->__invalid_rune = ntohl(rl->__invalid_rune);
 104         rl->__variable_len = ntohl(rl->__variable_len);
 105         rl->__runetype_ext.__nranges = ntohl(rl->__runetype_ext.__nranges);
 106         rl->__maplower_ext.__nranges = ntohl(rl->__maplower_ext.__nranges);
 107         rl->__mapupper_ext.__nranges = ntohl(rl->__mapupper_ext.__nranges);
 108
 109         for (x = 0; x < _CACHED_RUNES; ++x) {
 110                 rl->__runetype[x] = ntohl(rl->__runetype[x]);
 111                 rl->__maplower[x] = ntohl(rl->__maplower[x]);
 112                 rl->__mapupper[x] = ntohl(rl->__mapupper[x]);
 113         }
 114
 115         rl->__runetype_ext.__ranges = (_RuneEntry *)rl->__variable;
 116         rl->__variable = rl->__runetype_ext.__ranges +
 117             rl->__runetype_ext.__nranges;
 118         if (rl->__variable > lastp) {
 119                 free(data);
 120                 errno = EFTYPE;
 121                 return (NULL);
 122         }
 123
 124         rl->__maplower_ext.__ranges = (_RuneEntry *)rl->__variable;
 125         rl->__variable = rl->__maplower_ext.__ranges +
 126             rl->__maplower_ext.__nranges;
 127         if (rl->__variable > lastp) {
 128                 free(data);
 129                 errno = EFTYPE;
 130                 return (NULL);
 131         }
 132
 133         rl->__mapupper_ext.__ranges = (_RuneEntry *)rl->__variable;
 134         rl->__variable = rl->__mapupper_ext.__ranges +
 135             rl->__mapupper_ext.__nranges;
 136         if (rl->__variable > lastp) {
 137                 free(data);
 138                 errno = EFTYPE;
 139                 return (NULL);
 140         }
 141
 142         for (x = 0; x < rl->__runetype_ext.__nranges; ++x) {
 143                 rr = rl->__runetype_ext.__ranges;
 144
 145                 rr[x].__min = ntohl(rr[x].__min);
 146                 rr[x].__max = ntohl(rr[x].__max);
 147                 if ((rr[x].__map = ntohl(rr[x].__map)) == 0) {
 148                         int len = rr[x].__max - rr[x].__min + 1;
 149                         rr[x].__types = rl->__variable;
 150                         rl->__variable = rr[x].__types + len;
 151                         if (rl->__variable > lastp) {
 152                                 free(data);
 153                                 errno = EFTYPE;
 154                                 return (NULL);
 155                         }
 156                         while (len-- > 0)
 157                                 rr[x].__types[len] = ntohl(rr[x].__types[len]);
 158                 } else
 159                         rr[x].__types = 0;
 160         }
 161
 162         for (x = 0; x < rl->__maplower_ext.__nranges; ++x) {
 163                 rr = rl->__maplower_ext.__ranges;
 164
 165                 rr[x].__min = ntohl(rr[x].__min);
 166                 rr[x].__max = ntohl(rr[x].__max);
 167                 rr[x].__map = ntohl(rr[x].__map);
 168         }
 169
 170         for (x = 0; x < rl->__mapupper_ext.__nranges; ++x) {
 171                 rr = rl->__mapupper_ext.__ranges;
 172
 173                 rr[x].__min = ntohl(rr[x].__min);
 174                 rr[x].__max = ntohl(rr[x].__max);
 175                 rr[x].__map = ntohl(rr[x].__map);
 176         }
 177         if (((char *)rl->__variable) + rl->__variable_len > (char *)lastp) {
 178                 free(data);
 179                 errno = EFTYPE;
 180                 return (NULL);
 181         }
 182
 183         /*
 184          * Go out and zero pointers that should be zero.
 185          */
 186         if (!rl->__variable_len)
 187                 rl->__variable = 0;
 188
 189         if (!rl->__runetype_ext.__nranges)
 190                 rl->__runetype_ext.__ranges = 0;
 191
 192         if (!rl->__maplower_ext.__nranges)
 193                 rl->__maplower_ext.__ranges = 0;
 194
 195         if (!rl->__mapupper_ext.__nranges)
 196                 rl->__mapupper_ext.__ranges = 0;
 197
 198         return (rl);
 199 }