Changeset 32872


Ignore:
Timestamp:
2012-07-25T22:36:22+02:00 (6 years ago)
Author:
mhei
Message:

[packages] php5: upgrade to 5.4.5

  • php.ini: remove obsolete options
  • drop patch 'patches/900-prevent_buildconf_force.patch' as php now supports newer autoconf versions 'buildconf --force' can be called after patching the source tree to update build system
  • cross compiling issue regarding libdl still present, so because of the last point the corresponding patch has to be against configure.in but configure
  • update timezone patches
Location:
packages/lang/php5
Files:
1 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • packages/lang/php5/Makefile

    r32871 r32872  
    99 
    1010PKG_NAME:=php 
    11 PKG_VERSION:=5.3.10 
    12 PKG_RELEASE:=5 
     11PKG_VERSION:=5.4.5 
     12PKG_RELEASE:=1 
    1313 
    1414PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION).tar.bz2 
    1515PKG_SOURCE_URL:=http://www.php.net/distributions/ 
    16 PKG_MD5SUM:=816259e5ca7d0a7e943e56a3bb32b17f 
     16PKG_MD5SUM:=ffcc7f4dcf2b79d667fe0c110e6cb724 
    1717 
    1818PKG_FIXUP:=libtool no-autoreconf 
     
    4141        CONFIG_PACKAGE_php5-cgi CONFIG_PACKAGE_php5-cli \ 
    4242        $(patsubst %,CONFIG_PACKAGE_php5-mod-%,$(PHP5_MODULES)) \ 
    43         CONFIG_PHP5_FILTER CONFIG_PHP5_LIBXML CONFIG_PHP5_SYSTEMTZDATA 
     43        CONFIG_PHP5_FILTER CONFIG_PHP5_LIBXML PHP5_SYSTEMTZDATA 
    4444 
    4545include $(INCLUDE_DIR)/package.mk 
     
    134134        --with-config-file-path=/etc \ 
    135135        --with-config-file-scan-dir=/etc/php5 \ 
    136         --enable-magic-quotes \ 
    137136        --disable-short-tags \ 
    138137        \ 
     
    487486        $(INSTALL_DIR) $(1)/etc/init.d 
    488487        $(INSTALL_BIN) ./files/php5-fastcgi.init $(1)/etc/init.d/php5-fastcgi 
     488endef 
     489 
     490define Build/Prepare 
     491        $(call Build/Prepare/Default) 
     492        ( cd $(PKG_BUILD_DIR); touch configure.in; ./buildconf --force ) 
    489493endef 
    490494 
  • packages/lang/php5/files/php.ini

    r26824 r32872  
    1717unserialize_callback_func = 
    1818serialize_precision = 100 
    19 allow_call_time_pass_reference = On 
    20  
    21 safe_mode = Off 
    22 safe_mode_gid = Off 
    23 safe_mode_include_dir = 
    24 safe_mode_exec_dir = 
    25 safe_mode_allowed_env_vars = PHP_ 
    26 safe_mode_protected_env_vars = LD_LIBRARY_PATH 
     19 
    2720;open_basedir = 
    2821disable_functions = 
  • packages/lang/php5/patches/102-debian_patches_use_embedded_timezonedb.patch

    r28491 r32872  
    44 
    55History: 
    6 r7: per Sean Finney's review: simpler lat/long rounding, 
    7     use stat() not access() to check existence of timezone, 
    8     improve comments throughout. 
     6r8: fix compile error without --with-system-tzdata configured 
     7r7: improve check for valid timezone id to exclude directories 
    98r6: fix fd leak in r5, fix country code/BC flag use in  
    109    timezone_identifiers_list() using system db, 
     
    5049 #if (defined(__APPLE__) || defined(__APPLE_CC__)) && (defined(__BIG_ENDIAN__) || defined(__LITTLE_ENDIAN__)) 
    5150 # if defined(__LITTLE_ENDIAN__) 
    52 @@ -51,6 +66,11 @@ 
     51@@ -51,9 +66,14 @@ 
    5352  
    5453 static void read_preamble(const unsigned char **tzf, timelib_tzinfo *tz) 
    5554 { 
    56 +       if (memcmp(tzf, "TZif", 4) == 0) { 
    57 +               *tzf += 20; 
    58 +               return; 
    59 +       } 
    60 +     
    61         /* skip ID */ 
    62         *tzf += 4; 
    63          
    64 @@ -256,7 +276,435 @@ void timelib_dump_tzinfo(timelib_tzinfo 
     55-       /* skip ID */ 
     56-       *tzf += 4; 
     57-        
     58+        if (memcmp(tzf, "TZif", 4) == 0) { 
     59+                *tzf += 20; 
     60+                return; 
     61+        } 
     62+         
     63+        /* skip ID */ 
     64+        *tzf += 4; 
     65+                 
     66        /* read BC flag */ 
     67        tz->bc = (**tzf == '\1'); 
     68        *tzf += 1; 
     69@@ -256,7 +276,397 @@ void timelib_dump_tzinfo(timelib_tzinfo 
    6570        } 
    6671 } 
     
    7580+#endif 
    7681+ 
     82+/* System timezone database pointer. */ 
     83+static const timelib_tzdb *timezonedb_system = NULL; 
     84+ 
    7785+/* Hash table entry for the cache of the zone.tab mapping table. */ 
    7886+struct location_info { 
    79 +       char code[2]; /* Country code. */ 
    80 +       double latitude, longitude; 
    81 +       char name[64]; 
    82 +       char *comment; 
    83 +       struct location_info *next; 
     87+        char code[2]; 
     88+        double latitude, longitude; 
     89+        char name[64]; 
     90+        char *comment; 
     91+        struct location_info *next; 
    8492+}; 
    8593+ 
    86 +/* System timezone database pointer. */ 
    87 +static const timelib_tzdb *timezonedb_system = NULL; 
    88 + 
    89 +/* Cache of zone.tab location data. */ 
     94+/* Cache of zone.tab. */ 
    9095+static struct location_info **system_location_table; 
    9196+ 
     
    9499+#define LOCINFO_HASH_SIZE (1021) 
    95100+ 
    96 +/* Hash function for indexing the location_info hash table. */ 
    97101+static uint32_t tz_hash(const char *str) 
    98102+{ 
    99 +       const unsigned char *p = (const unsigned char *)str; 
    100 +       uint32_t hash = 5381; 
    101 +       int c; 
    102 +        
    103 +       while ((c = *p++) != '\0') { 
    104 +               hash = (hash << 5) ^ hash ^ c; 
    105 +       } 
    106 +        
    107 +       return hash % LOCINFO_HASH_SIZE; 
    108 +} 
    109 + 
    110 +/* Parse an ISO-6709 co-ordinate as used in zone.tab. Returns end of 
    111 + * the parsed string on success, or NULL on parse error.  On success, 
     103+    const unsigned char *p = (const unsigned char *)str; 
     104+    uint32_t hash = 5381; 
     105+    int c; 
     106+     
     107+    while ((c = *p++) != '\0') { 
     108+        hash = (hash << 5) ^ hash ^ c; 
     109+    } 
     110+     
     111+    return hash % LOCINFO_HASH_SIZE; 
     112+} 
     113+ 
     114+/* Parse an ISO-6709 date as used in zone.tab. Returns end of the 
     115+ * parsed string on success, or NULL on parse error.  On success, 
    112116+ * writes the parsed number to *result. */ 
    113117+static char *parse_iso6709(char *p, double *result) 
    114118+{ 
    115 +       double v, sign; 
    116 +       char *pend; 
    117 +       size_t len; 
    118 + 
    119 +       if (*p == '+') 
    120 +               sign = 1.0; 
    121 +       else if (*p == '-') 
    122 +               sign = -1.0; 
    123 +       else 
    124 +               return NULL; 
    125 + 
    126 +       p++; 
    127 +       for (pend = p; *pend >= '0' && *pend <= '9'; pend++) 
    128 +               ;; 
    129 + 
    130 +       /* Annoying encoding used by zone.tab has no decimal point, so use 
    131 +        * the length to determine the format: 
    132 +        *  
    133 +        * 4 = DDMM 
    134 +        * 5 = DDDMM 
    135 +        * 6 = DDMMSS 
    136 +        * 7 = DDDMMSS 
    137 +        */ 
    138 +       len = pend - p; 
    139 +       if (len < 4 || len > 7) { 
    140 +               return NULL; 
    141 +       } 
    142 + 
    143 +       /* p => [D]DD */ 
    144 +       v = (p[0] - '0') * 10.0 + (p[1] - '0'); 
    145 +       p += 2; 
    146 +       if (len == 5 || len == 7) 
    147 +               v = v * 10.0 + (*p++ - '0'); 
    148 +       /* p => MM[SS] */ 
    149 +       v += (10.0 * (p[0] - '0') 
    150 +                 + p[1] - '0') / 60.0; 
    151 +       p += 2; 
    152 +       /* p => [SS] */ 
    153 +       if (len > 5) { 
    154 +               v += (10.0 * (p[0] - '0') 
    155 +                         + p[1] - '0') / 3600.0; 
    156 +               p += 2; 
    157 +       } 
    158 + 
    159 +       /* Round to five decimal place, not because it's a good idea, 
    160 +        * but, because the builtin data uses rounded data, so, match 
    161 +        * that. */ 
    162 +       *result = sign * (int)(v * 100000.0 + 0.5) / 100000.0; 
    163 + 
    164 +       return p; 
     119+    double v, sign; 
     120+    char *pend; 
     121+    size_t len; 
     122+ 
     123+    if (*p == '+') 
     124+        sign = 1.0; 
     125+    else if (*p == '-') 
     126+        sign = -1.0; 
     127+    else 
     128+        return NULL; 
     129+ 
     130+    p++; 
     131+    for (pend = p; *pend >= '0' && *pend <= '9'; pend++) 
     132+        ;; 
     133+ 
     134+    /* Annoying encoding used by zone.tab has no decimal point, so use 
     135+    * the length to determine the format: 
     136+    *  
     137+    * 4 = DDMM 
     138+    * 5 = DDDMM 
     139+    * 6 = DDMMSS 
     140+    * 7 = DDDMMSS 
     141+    */ 
     142+    len = pend - p; 
     143+    if (len < 4 || len > 7) { 
     144+        return NULL; 
     145+    } 
     146+ 
     147+    /* p => [D]DD */ 
     148+    v = (p[0] - '0') * 10.0 + (p[1] - '0'); 
     149+    p += 2; 
     150+    if (len == 5 || len == 7) 
     151+        v = v * 10.0 + (*p++ - '0'); 
     152+    /* p => MM[SS] */ 
     153+    v += (10.0 * (p[0] - '0') 
     154+          + p[1] - '0') / 60.0; 
     155+    p += 2; 
     156+    /* p => [SS] */ 
     157+    if (len > 5) { 
     158+        v += (10.0 * (p[0] - '0') 
     159+              + p[1] - '0') / 3600.0; 
     160+        p += 2; 
     161+    } 
     162+ 
     163+    /* Round to five decimal place, not because it's a good idea, 
     164+    * but, because the builtin data uses rounded data, so, match 
     165+    * that. */ 
     166+    *result = round(v * sign * 100000.0) / 100000.0; 
     167+ 
     168+    return p; 
    165169+} 
    166170+ 
    167171+/* This function parses the zone.tab file to build up the mapping of 
    168172+ * timezone to country code and geographic location, and returns a 
    169 + * hash table. The hash table is indexed by the function: 
     173+ * hash table.  The hash table is indexed by the function: 
    170174+ * 
    171 + *      tz_hash(timezone-name) 
     175+ *  tz_hash(timezone-name) 
    172176+ */ 
    173177+static struct location_info **create_location_table(void) 
    174178+{ 
    175 +       struct location_info **li, *i; 
    176 +       char zone_tab[PATH_MAX]; 
    177 +       char line[512]; 
    178 +       FILE *fp; 
    179 + 
    180 +       strncpy(zone_tab, ZONEINFO_PREFIX "/zone.tab", sizeof zone_tab); 
    181 + 
    182 +       fp = fopen(zone_tab, "r"); 
    183 +       if (!fp) { 
    184 +               return NULL; 
    185 +       } 
    186 + 
    187 +       li = calloc(LOCINFO_HASH_SIZE, sizeof *li); 
    188 + 
    189 +       while (fgets(line, sizeof line, fp)) { 
    190 +               char *p = line, *code, *name, *comment; 
    191 +               uint32_t hash; 
    192 +               double latitude, longitude; 
    193 + 
    194 +               while (isspace(*p)) 
    195 +                       p++; 
    196 + 
    197 +               if (*p == '#' || *p == '\0' || *p == '\n') 
    198 +                       continue; 
    199 +                
    200 +               if (!isalpha(p[0]) || !isalpha(p[1]) || p[2] != '\t') 
    201 +                       continue; 
    202 +                
    203 +               /* code => AA */ 
    204 +               code = p; 
    205 +               p[2] = 0; 
    206 +               p += 3; 
    207 + 
    208 +               /* coords => [+-][D]DDMM[SS][+-][D]DDMM[SS] */ 
    209 +               p = parse_iso6709(p, &latitude); 
    210 +               if (!p) { 
    211 +                       continue; 
    212 +               } 
    213 +               p = parse_iso6709(p, &longitude); 
    214 +               if (!p) { 
    215 +                       continue; 
    216 +               } 
    217 + 
    218 +               if (!p || *p != '\t') { 
    219 +                       continue; 
    220 +               } 
    221 + 
    222 +               /* name = string */ 
    223 +               name = ++p; 
    224 +               while (*p != '\t' && *p && *p != '\n') 
    225 +                       p++; 
    226 + 
    227 +               *p++ = '\0'; 
    228 + 
    229 +               /* comment = string */ 
    230 +               comment = p; 
    231 +               while (*p != '\t' && *p && *p != '\n') 
    232 +                       p++; 
    233 + 
    234 +               if (*p == '\n' || *p == '\t') 
    235 +                       *p = '\0'; 
    236 +                
    237 +               hash = tz_hash(name); 
    238 +               i = malloc(sizeof *i); 
    239 +               memcpy(i->code, code, 2); 
    240 +               strncpy(i->name, name, sizeof i->name); 
    241 +               i->comment = strdup(comment); 
    242 +               i->longitude = longitude; 
    243 +               i->latitude = latitude; 
    244 +               i->next = li[hash]; 
    245 +               li[hash] = i; 
    246 +               /* printf("%s [%u, %f, %f]\n", name, hash, latitude, longitude); */ 
    247 +       } 
    248 + 
    249 +       fclose(fp); 
    250 + 
    251 +       return li; 
     179+    struct location_info **li, *i; 
     180+    char zone_tab[PATH_MAX]; 
     181+    char line[512]; 
     182+    FILE *fp; 
     183+ 
     184+    strncpy(zone_tab, ZONEINFO_PREFIX "/zone.tab", sizeof zone_tab); 
     185+ 
     186+    fp = fopen(zone_tab, "r"); 
     187+    if (!fp) { 
     188+        return NULL; 
     189+    } 
     190+ 
     191+    li = calloc(LOCINFO_HASH_SIZE, sizeof *li); 
     192+ 
     193+    while (fgets(line, sizeof line, fp)) { 
     194+        char *p = line, *code, *name, *comment; 
     195+        uint32_t hash; 
     196+        double latitude, longitude; 
     197+ 
     198+        while (isspace(*p)) 
     199+            p++; 
     200+ 
     201+        if (*p == '#' || *p == '\0' || *p == '\n') 
     202+            continue; 
     203+         
     204+        if (!isalpha(p[0]) || !isalpha(p[1]) || p[2] != '\t') 
     205+            continue; 
     206+         
     207+        /* code => AA */ 
     208+        code = p; 
     209+        p[2] = 0; 
     210+        p += 3; 
     211+ 
     212+        /* coords => [+-][D]DDMM[SS][+-][D]DDMM[SS] */ 
     213+        p = parse_iso6709(p, &latitude); 
     214+        if (!p) { 
     215+            continue; 
     216+        } 
     217+        p = parse_iso6709(p, &longitude); 
     218+        if (!p) { 
     219+            continue; 
     220+        } 
     221+ 
     222+        if (!p || *p != '\t') { 
     223+            continue; 
     224+        } 
     225+ 
     226+        /* name = string */ 
     227+        name = ++p; 
     228+        while (*p != '\t' && *p && *p != '\n') 
     229+            p++; 
     230+ 
     231+        *p++ = '\0'; 
     232+ 
     233+        /* comment = string */ 
     234+        comment = p; 
     235+        while (*p != '\t' && *p && *p != '\n') 
     236+            p++; 
     237+ 
     238+        if (*p == '\n' || *p == '\t') 
     239+            *p = '\0'; 
     240+         
     241+        hash = tz_hash(name); 
     242+        i = malloc(sizeof *i); 
     243+        memcpy(i->code, code, 2); 
     244+        strncpy(i->name, name, sizeof i->name); 
     245+        i->comment = strdup(comment); 
     246+        i->longitude = longitude; 
     247+        i->latitude = latitude; 
     248+        i->next = li[hash]; 
     249+        li[hash] = i; 
     250+        /* printf("%s [%u, %f, %f]\n", name, hash, latitude, longitude); */ 
     251+    } 
     252+ 
     253+    fclose(fp); 
     254+ 
     255+    return li; 
    252256+} 
    253257+ 
     
    255259+ * Returns NULL if the name could not be found. */ 
    256260+const struct location_info *find_zone_info(struct location_info **li,  
    257 +                                                                                  const char *name) 
    258 +{ 
    259 +       uint32_t hash = tz_hash(name); 
    260 +       const struct location_info *l; 
    261 + 
    262 +       if (!li) { 
    263 +               return NULL; 
    264 +       } 
    265 + 
    266 +       for (l = li[hash]; l; l = l->next) { 
    267 +               if (strcasecmp(l->name, name) == 0) 
    268 +                       return l; 
    269 +       } 
    270 + 
    271 +       return NULL; 
    272 +}       
     261+                                           const char *name) 
     262+{ 
     263+    uint32_t hash = tz_hash(name); 
     264+    const struct location_info *l; 
     265+ 
     266+    if (!li) { 
     267+        return NULL; 
     268+    } 
     269+ 
     270+    for (l = li[hash]; l; l = l->next) { 
     271+        if (strcasecmp(l->name, name) == 0) 
     272+            return l; 
     273+    } 
     274+ 
     275+    return NULL; 
     276+}     
    273277+ 
    274278+/* Filter out some non-tzdata files and the posix/right databases, if 
     
    284288+} 
    285289+ 
    286 +/* Comparison callback for qsort(), used to alpha-sort the index 
    287 + * array by timezone name. */ 
    288290+static int sysdbcmp(const void *first, const void *second) 
    289291+{ 
    290 +       const timelib_tzdb_index_entry *alpha = first, *beta = second; 
    291 +        
    292 +       return strcmp(alpha->id, beta->id); 
     292+        const timelib_tzdb_index_entry *alpha = first, *beta = second; 
     293+ 
     294+        return strcmp(alpha->id, beta->id); 
    293295+} 
    294296+ 
     
    345347+                                               dirstack_size *= 2; 
    346348+                                               dirstack = realloc(dirstack,  
    347 +                                                                                  dirstack_size * sizeof *dirstack); 
     349+                                                                  dirstack_size * sizeof *dirstack); 
    348350+                                       } 
    349351+                                       dirstack[dirstack_top++] = strdup(name); 
     
    353355+                                               index_size *= 2; 
    354356+                                               db_index = realloc(db_index, 
    355 +                                                                                  index_size * sizeof *db_index); 
     357+                                                                  index_size * sizeof *db_index); 
    356358+                                       } 
    357359+ 
     
    367369+       } while (dirstack_top); 
    368370+ 
    369 +       /* Alpha-sort the index array; shouldn't be technically necessary 
    370 +        * but some of the test cases rely on this, and, it matches the 
    371 +        * builtin database. */ 
    372 +       qsort(db_index, index_next, sizeof *db_index, sysdbcmp); 
    373 +        
     371+        qsort(db_index, index_next, sizeof *db_index, sysdbcmp); 
     372+ 
    374373+       db->index = db_index; 
    375374+       db->index_size = index_next; 
     
    379378+ 
    380379+#define FAKE_HEADER "1234\0??\1??" 
    381 +#define FAKE_BC_POS (0) 
    382380+#define FAKE_UTC_POS (7 - 4) 
    383381+ 
    384 +/* Create a fake data segment for database 'sysdb'.   This mocks 
    385 + * up a fake ->data segment for the given timezone database.  
    386 + * php_date.c::timezone_identifiers_list() looks at data[pos + 4] 
    387 + * through data[pos + 6] to compare the country code and BC flag,  
    388 + * which are stored in the builtin data array like: 
    389 + * 
    390 + *    (pos + 4) => BC flag 
    391 + *    (pos + 5, pos + 6) => Two chars of country code 
    392 + * 
    393 + * where pos is the index corresponding to the timezone name. 
    394 + * 
    395 + * Timezone names are classified here into three types: 
    396 + *    1) UTC, which is special 
    397 + *    2) "normal" zone names 
    398 + *    3) "backwards-compat" zone names 
    399 + * 
    400 + * (boolean logic of the BC flag seems to be inverted, but hey) 
    401 + * 
    402 + * UTC is special since it has BC=\1, code = "??" 
    403 + * "normal" zones exist in zone.tab and have the given c-code and BC=\1 
    404 + * "backwards-compat" zones don't exist in zone.tab and have BC=\0 
    405 + * 
    406 + * Since UTC and the BC zones are constant, they are encoded in the 
    407 + * FAKE_HEADER prefix, and pos pointers index into that. 
    408 + * 
    409 + * FAKE_HEADER is hence four random bytes, then the BC zone segment 
    410 + * (three bytes), then the UTC zone segment (another three). 
    411 + * 
    412 + * For all "normal" zones, three bytes are appended to the data array; 
    413 + * the BC flag, always 1, and the two bytes of country code. 
    414 + */ 
     382+/* Create a fake data segment for database 'sysdb'. */ 
    415383+static void fake_data_segment(timelib_tzdb *sysdb, 
    416 +                                                         struct location_info **info) 
    417 +{ 
    418 +       size_t n; 
    419 +       char *data, *p; 
    420 +        
    421 +       /* Worst case maximum is 3 bytes per zone, plus the header. */ 
    422 +       data = malloc((3 * sysdb->index_size) + sizeof(FAKE_HEADER) - 1); 
    423 +        
    424 +       /* Append the fake header, p then = next byte */ 
    425 +       p = mempcpy(data, FAKE_HEADER, sizeof(FAKE_HEADER) - 1); 
    426 +        
    427 +       for (n = 0; n < sysdb->index_size; n++) { 
    428 +               const struct location_info *li; 
    429 +               timelib_tzdb_index_entry *ent; 
    430 +                
    431 +               /* Lost const'ness since we're modifying the pos pointer. */ 
    432 +               ent = (timelib_tzdb_index_entry *)&sysdb->index[n]; 
    433 +                
    434 +               /* Lookup the timezone name in the hash table. */ 
    435 +               if (strcmp(ent->id, "UTC") == 0) { 
    436 +                       ent->pos = FAKE_UTC_POS; 
    437 +                       continue; 
    438 +               } 
    439 +                
    440 +               li = find_zone_info(info, ent->id); 
    441 +               if (li) { 
    442 +                       /* If found, append the BC byte and the country code; set 
    443 +                        * the position index for the timezone to point to 
    444 +                        * this.  */ 
    445 +                       ent->pos = (p - data) - 4; 
    446 +                       *p++ = '\x01'; 
    447 +                       *p++ = li->code[0]; 
    448 +                       *p++ = li->code[1]; 
    449 +               } 
    450 +               else { 
    451 +                       /* If not found, the timezone data can 
    452 +                        * point at the header. */ 
    453 +                       ent->pos = 0; 
    454 +               } 
    455 +       } 
    456 +        
    457 +       /* Store the fake data array */ 
    458 +       sysdb->data = (unsigned char *)data; 
    459 +} 
    460 + 
    461 +/* Evaluates to true if given timezone name is valid. */ 
    462 +#define is_valid_tz_name(tz_) (tz_[0] && strstr(tz_, "..") == NULL) 
    463 + 
    464 +/* Return the mmap()ed tzfile if found, else NULL.     On success, the 
     384+                              struct location_info **info) 
     385+{ 
     386+        size_t n; 
     387+        char *data, *p; 
     388+         
     389+        data = malloc(3 * sysdb->index_size + 7); 
     390+ 
     391+        p = mempcpy(data, FAKE_HEADER, sizeof(FAKE_HEADER) - 1); 
     392+ 
     393+        for (n = 0; n < sysdb->index_size; n++) { 
     394+                const struct location_info *li; 
     395+                timelib_tzdb_index_entry *ent; 
     396+ 
     397+                ent = (timelib_tzdb_index_entry *)&sysdb->index[n]; 
     398+ 
     399+                /* Lookup the timezone name in the hash table. */ 
     400+                if (strcmp(ent->id, "UTC") == 0) { 
     401+                        ent->pos = FAKE_UTC_POS; 
     402+                        continue; 
     403+                } 
     404+ 
     405+                li = find_zone_info(info, ent->id); 
     406+                if (li) { 
     407+                        /* If found, append the BC byte and the 
     408+                         * country code; set the position for this 
     409+                         * section of timezone data.  */ 
     410+                        ent->pos = (p - data) - 4; 
     411+                        *p++ = '\1'; 
     412+                        *p++ = li->code[0]; 
     413+                        *p++ = li->code[1]; 
     414+                } 
     415+                else { 
     416+                        /* If not found, the timezone data can 
     417+                         * point at the header. */ 
     418+                        ent->pos = 0; 
     419+                } 
     420+        } 
     421+         
     422+        sysdb->data = (unsigned char *)data; 
     423+} 
     424+ 
     425+/* Returns true if the passed-in stat structure describes a 
     426+ * probably-valid timezone file. */ 
     427+static int is_valid_tzfile(const struct stat *st) 
     428+{ 
     429+       return S_ISREG(st->st_mode) && st->st_size > 20; 
     430+} 
     431+ 
     432+/* Return the mmap()ed tzfile if found, else NULL.  On success, the 
    465433+ * length of the mapped data is placed in *length. */ 
    466434+static char *map_tzfile(const char *timezone, size_t *length) 
     
    471439+       int fd; 
    472440+        
    473 +       if (!is_valid_tz_name(timezone)) { 
     441+       if (timezone[0] == '\0' || strstr(timezone, "..") != NULL) { 
    474442+               return NULL; 
    475443+       } 
     
    480448+       if (fd == -1) { 
    481449+               return NULL; 
    482 +       } else if (fstat(fd, &st) != 0 || st.st_size < 21) { 
     450+       } else if (fstat(fd, &st) != 0 || !is_valid_tzfile(&st)) { 
    483451+               close(fd); 
    484452+               return NULL; 
     
    491459+       return p != MAP_FAILED ? p : NULL; 
    492460+} 
    493 +#endif 
    494 + 
    495 +/* seek_to_tz_position() for a builtin/external database. */ 
    496 +static int inmem_seek_to_tz_position(const unsigned char **tzf,  
    497 +                                                                        char *timezone, const timelib_tzdb *tzdb) 
     461+ 
     462+#endif 
     463+ 
     464+static int inmem_seek_to_tz_position(const unsigned char **tzf, char *timezone, const timelib_tzdb *tzdb) 
    498465 { 
    499466        int left = 0, right = tzdb->index_size - 1; 
    500467 #ifdef HAVE_SETLOCALE 
    501 @@ -295,36 +743,131 @@ static int seek_to_tz_position(const uns 
     468@@ -295,36 +705,125 @@ static int seek_to_tz_position(const uns 
    502469        return 0; 
    503470 } 
    504471  
    505 +/* Modified seek_to_tz_position wrapper which handles the system 
    506 + * database and the builtin/external databases in the same way. 
    507 + * Returns zero on failure on non-zero on success.  On success, (*map, 
    508 + * *maplen) is an mmap'ed region if *map is non-NULL, and must be 
    509 + * munmaped after use.  */ 
    510472+static int seek_to_tz_position(const unsigned char **tzf, char *timezone,  
    511 +                                                          char **map, size_t *maplen, 
    512 +                                                          const timelib_tzdb *tzdb) 
    513 +{ 
    514 +#ifdef HAVE_SYSTEM_TZDATA 
     473+                              char **map, size_t *maplen, 
     474+                              const timelib_tzdb *tzdb) 
     475+{ 
    515476+       if (tzdb == timezonedb_system) { 
    516477+               char *orig; 
     
    523484+               (*tzf) = (unsigned char *)orig ; 
    524485+               *map = orig; 
    525 +                                
    526 +               return 1; 
     486+                 
     487+                return 1; 
    527488+       } 
    528 +       else  
    529 +#endif 
    530 +       { 
     489+       else { 
    531490+               return inmem_seek_to_tz_position(tzf, timezone, tzdb); 
    532491+       } 
     
    543502+               create_zone_index(tmp); 
    544503+               system_location_table = create_location_table(); 
    545 +               fake_data_segment(tmp, system_location_table); 
     504+                fake_data_segment(tmp, system_location_table); 
    546505+               timezonedb_system = tmp; 
    547506+       } 
     507+ 
    548508+                        
    549509+       return timezonedb_system; 
     
    570530+ 
    571531+#ifdef HAVE_SYSTEM_TZDATA 
    572 +       if (tzdb == timezonedb_system) { 
    573 +               char fname[PATH_MAX]; 
    574 +               struct stat st; 
    575 +                
    576 +               if (!is_valid_tz_name(timezone)) { 
    577 +                       return 0; 
    578 +               } 
    579 +         
    580 +               snprintf(fname, sizeof fname, ZONEINFO_PREFIX "/%s", timezone); 
    581 +         
    582 +               return stat(fname, &st) == 0 && S_ISREG(st.st_mode); 
    583 +       } 
     532+        if (tzdb == timezonedb_system) { 
     533+            char fname[PATH_MAX]; 
     534+            struct stat st; 
     535+ 
     536+            if (timezone[0] == '\0' || strstr(timezone, "..") != NULL) { 
     537+               return 0; 
     538+            } 
     539+             
     540+            snprintf(fname, sizeof fname, ZONEINFO_PREFIX "/%s", timezone); 
     541+             
     542+            return stat(fname, &st) == 0 && is_valid_tzfile(&st); 
     543+        } 
    584544+#endif 
    585545+ 
     
    607567+               if (memmap) { 
    608568+                       const struct location_info *li; 
    609 +                        
     569+ 
    610570+                       /* TZif-style - grok the location info from the system database, 
    611571+                        * if possible. */ 
     572+ 
    612573+                       if ((li = find_zone_info(system_location_table, timezone)) != NULL) { 
    613574+                               tmp->location.comments = strdup(li->comment); 
    614 +                               strncpy(tmp->location.country_code, li->code, 2); 
     575+                                strncpy(tmp->location.country_code, li->code, 2); 
    615576+                               tmp->location.longitude = li->longitude; 
    616577+                               tmp->location.latitude = li->latitude; 
  • packages/lang/php5/patches/103-debian_patches_use_embedded_timezonedb.patch

    r29752 r32872  
    66 patch, we actually feel quite comfortable using the default timezone info. 
    77Bug-Debian: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=571762 
    8 --- a/ext/date/php_date.c 
    9 +++ b/ext/date/php_date.c 
    10 @@ -886,7 +886,7 @@ static char* guess_timezone(const timeli 
    11                         tzid = "UTC"; 
    12                 } 
    13                  
    14 -               php_error_docref(NULL TSRMLS_CC, E_WARNING, DATE_TZ_ERRMSG "We selected '%s' for '%s/%.1f/%s' instead", tzid, ta ? ta->tm_zone : "Unknown", ta ? (float) (ta->tm_gmtoff / 3600) : 0, ta ? (ta->tm_isdst ? "DST" : "no DST") : "Unknown"); 
    15 +               // php_error_docref(NULL TSRMLS_CC, E_WARNING, DATE_TZ_ERRMSG "We selected '%s' for '%s/%.1f/%s' instead", tzid, ta ? ta->tm_zone : "Unknown", ta ? (float) (ta->tm_gmtoff / 3600) : 0, ta ? (ta->tm_isdst ? "DST" : "no DST") : "Unknown"); 
    16                 return tzid; 
    17         } 
    18  #endif 
    19 --- a/ext/date/tests/date_default_timezone_get-1.phpt 
    20 +++ /dev/null 
    21 @@ -1,16 +0,0 @@ 
    22 ---TEST-- 
    23 -date_default_timezone_get() function [1] 
    24 ---INI-- 
    25 -date.timezone= 
    26 ---FILE-- 
    27 -<?php 
    28 -       putenv('TZ='); 
    29 -       echo date_default_timezone_get(), "\n"; 
    30 -       echo date('e'), "\n"; 
    31 -?> 
    32 ---EXPECTF-- 
    33 -Warning: date_default_timezone_get(): It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected 'UTC' for 'UTC/0.0/no DST' instead in %sdate_default_timezone_get-1.php on line 3 
    34 -UTC 
    35 - 
    36 -Warning: date(): It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected 'UTC' for 'UTC/0.0/no DST' instead in %sdate_default_timezone_get-1.php on line 4 
    37 -UTC 
    38 --- a/ext/date/tests/date_default_timezone_get-2.phpt 
    39 +++ /dev/null 
    40 @@ -1,12 +0,0 @@ 
    41 ---TEST-- 
    42 -date_default_timezone_get() function [2] 
    43 ---INI-- 
    44 -date.timezone= 
    45 ---FILE-- 
    46 -<?php 
    47 -       putenv('TZ='); 
    48 -       echo date_default_timezone_get(), "\n"; 
    49 -?> 
    50 ---EXPECTF-- 
    51 -Warning: date_default_timezone_get(): It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected 'UTC' for 'UTC/0.0/no DST' instead in %sdate_default_timezone_get-2.php on line 3 
    52 -UTC 
    538--- a/ext/date/tests/date_default_timezone_set-1.phpt 
    549+++ b/ext/date/tests/date_default_timezone_set-1.phpt 
     
    5712 ?> 
    5813 --EXPECTF-- 
    59 -Warning: strtotime(): It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected 'UTC' for 'UTC/0.0/no DST' instead in %sdate_default_timezone_set-1.php on line 3 
     14-Warning: strtotime(): It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected the timezone 'UTC' for now, but please set date.timezone to select your timezone. in %sdate_default_timezone_set-1.php on line 3 
    6015- 
    61 -Warning: strtotime(): It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected 'UTC' for 'UTC/0.0/no DST' instead in %sdate_default_timezone_set-1.php on line 4 
     16-Warning: strtotime(): It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected the timezone 'UTC' for now, but please set date.timezone to select your timezone. in %sdate_default_timezone_set-1.php on line 4 
    6217 America/Indiana/Knox 
    6318 2005-01-12T03:00:00-0500 
  • packages/lang/php5/patches/950-Fix-dl-cross-compiling-issue.patch

    r29752 r32872  
    1 --- a/configure 
    2 +++ b/configure 
    3 @@ -16357,7 +16357,7 @@ fi 
    4      ac_libs=$LIBS 
    5      LIBS="$LIBS -ldl" 
    6      if test "$cross_compiling" = yes; then 
    7 -  found=no 
    8 +  found=$found 
    9  else 
    10    cat > conftest.$ac_ext <<EOF 
    11  #line 16364 "configure" 
     1--- a/configure.in 
     2+++ b/configure.in 
     3@@ -453,7 +453,10 @@ PHP_CHECK_FUNC(gethostname, nsl) 
     4 PHP_CHECK_FUNC(gethostbyaddr, nsl) 
     5 PHP_CHECK_FUNC(yp_get_default_domain, nsl) 
     6  
     7-PHP_CHECK_FUNC(dlopen, dl) 
     8+PHP_ADD_LIBRARY(dl) 
     9+PHP_DEF_HAVE(dlopen) 
     10+PHP_DEF_HAVE(libdl) 
     11+ac_cv_func_dlopen=yes 
     12 if test "$ac_cv_func_dlopen" = "yes"; then 
     13   AC_DEFINE(HAVE_LIBDL, 1, [ ]) 
     14 fi 
Note: See TracChangeset for help on using the changeset viewer.