PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/standard - pack.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 398 508 78.3 %
Date: 2016-09-27 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2016 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Author: Chris Schneider <cschneid@relog.ch>                          |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : /* $Id$ */
      19             : 
      20             : #include "php.h"
      21             : 
      22             : #include <stdio.h>
      23             : #include <stdlib.h>
      24             : #include <errno.h>
      25             : #include <sys/types.h>
      26             : #include <sys/stat.h>
      27             : #include <fcntl.h>
      28             : #ifdef PHP_WIN32
      29             : #define O_RDONLY _O_RDONLY
      30             : #include "win32/param.h"
      31             : #elif defined(NETWARE)
      32             : #ifdef USE_WINSOCK
      33             : #include <novsock2.h>
      34             : #else
      35             : #include <sys/socket.h>
      36             : #endif
      37             : #include <sys/param.h>
      38             : #else
      39             : #include <sys/param.h>
      40             : #endif
      41             : #include "ext/standard/head.h"
      42             : #include "php_string.h"
      43             : #include "pack.h"
      44             : #if HAVE_PWD_H
      45             : #ifdef PHP_WIN32
      46             : #include "win32/pwd.h"
      47             : #else
      48             : #include <pwd.h>
      49             : #endif
      50             : #endif
      51             : #include "fsock.h"
      52             : #if HAVE_NETINET_IN_H
      53             : #include <netinet/in.h>
      54             : #endif
      55             : 
      56             : #define INC_OUTPUTPOS(a,b) \
      57             :         if ((a) < 0 || ((INT_MAX - outputpos)/((int)b)) < (a)) { \
      58             :                 efree(formatcodes);     \
      59             :                 efree(formatargs);      \
      60             :                 php_error_docref(NULL, E_WARNING, "Type %c: integer overflow in format string", code); \
      61             :                 RETURN_FALSE; \
      62             :         } \
      63             :         outputpos += (a)*(b);
      64             : 
      65             : /* Whether machine is little endian */
      66             : char machine_little_endian;
      67             : 
      68             : /* Mapping of byte from char (8bit) to long for machine endian */
      69             : static int byte_map[1];
      70             : 
      71             : /* Mappings of bytes from int (machine dependent) to int for machine endian */
      72             : static int int_map[sizeof(int)];
      73             : 
      74             : /* Mappings of bytes from shorts (16bit) for all endian environments */
      75             : static int machine_endian_short_map[2];
      76             : static int big_endian_short_map[2];
      77             : static int little_endian_short_map[2];
      78             : 
      79             : /* Mappings of bytes from longs (32bit) for all endian environments */
      80             : static int machine_endian_long_map[4];
      81             : static int big_endian_long_map[4];
      82             : static int little_endian_long_map[4];
      83             : 
      84             : #if SIZEOF_ZEND_LONG > 4
      85             : /* Mappings of bytes from quads (64bit) for all endian environments */
      86             : static int machine_endian_longlong_map[8];
      87             : static int big_endian_longlong_map[8];
      88             : static int little_endian_longlong_map[8];
      89             : #endif
      90             : 
      91             : /* {{{ php_pack
      92             :  */
      93      504657 : static void php_pack(zval *val, size_t size, int *map, char *output)
      94             : {
      95             :         size_t i;
      96             :         char *v;
      97             : 
      98      504657 :         convert_to_long_ex(val);
      99      504657 :         v = (char *) &Z_LVAL_P(val);
     100             : 
     101     1041719 :         for (i = 0; i < size; i++) {
     102      537062 :                 *output++ = v[map[i]];
     103             :         }
     104      504657 : }
     105             : /* }}} */
     106             : 
     107             : /* pack() idea stolen from Perl (implemented formats behave the same as there except J and P)
     108             :  * Implemented formats are Z, A, a, h, H, c, C, s, S, i, I, l, L, n, N, q, Q, J, P, f, d, x, X, @.
     109             :  */
     110             : /* {{{ proto string pack(string format, mixed arg1 [, mixed arg2 [, mixed ...]])
     111             :    Takes one or more arguments and packs them into a binary string according to the format argument */
     112      153506 : PHP_FUNCTION(pack)
     113             : {
     114      153506 :         zval *argv = NULL;
     115      153506 :         int num_args = 0;
     116             :         size_t i;
     117             :         int currentarg;
     118             :         char *format;
     119             :         size_t formatlen;
     120             :         char *formatcodes;
     121             :         int *formatargs;
     122      153506 :         size_t formatcount = 0;
     123      153506 :         int outputpos = 0, outputsize = 0;
     124             :         zend_string *output;
     125             : 
     126      153506 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s*", &format, &formatlen, &argv, &num_args) == FAILURE) {
     127           0 :                 return;
     128             :         }
     129             : 
     130             :         /* We have a maximum of <formatlen> format codes to deal with */
     131      153506 :         formatcodes = safe_emalloc(formatlen, sizeof(*formatcodes), 0);
     132      153506 :         formatargs = safe_emalloc(formatlen, sizeof(*formatargs), 0);
     133      153506 :         currentarg = 0;
     134             : 
     135             :         /* Preprocess format into formatcodes and formatargs */
     136      309414 :         for (i = 0; i < formatlen; formatcount++) {
     137      155908 :                 char code = format[i++];
     138      155908 :                 int arg = 1;
     139             : 
     140             :                 /* Handle format arguments if any */
     141      155908 :                 if (i < formatlen) {
     142      153963 :                         char c = format[i];
     143             : 
     144      153963 :                         if (c == '*') {
     145         118 :                                 arg = -1;
     146         118 :                                 i++;
     147             :                         }
     148      153845 :                         else if (c >= '0' && c <= '9') {
     149      152129 :                                 arg = atoi(&format[i]);
     150             : 
     151      456968 :                                 while (format[i] >= '0' && format[i] <= '9' && i < formatlen) {
     152      152710 :                                         i++;
     153             :                                 }
     154             :                         }
     155             :                 }
     156             : 
     157             :                 /* Handle special arg '*' for all codes and check argv overflows */
     158      155908 :                 switch ((int) code) {
     159             :                         /* Never uses any args */
     160             :                         case 'x':
     161             :                         case 'X':
     162             :                         case '@':
     163           1 :                                 if (arg < 0) {
     164           0 :                                         php_error_docref(NULL, E_WARNING, "Type %c: '*' ignored", code);
     165           0 :                                         arg = 1;
     166             :                                 }
     167           1 :                                 break;
     168             : 
     169             :                         /* Always uses one arg */
     170             :                         case 'a':
     171             :                         case 'A':
     172             :                         case 'Z':
     173             :                         case 'h':
     174             :                         case 'H':
     175         988 :                                 if (currentarg >= num_args) {
     176           0 :                                         efree(formatcodes);
     177           0 :                                         efree(formatargs);
     178           0 :                                         php_error_docref(NULL, E_WARNING, "Type %c: not enough arguments", code);
     179           0 :                                         RETURN_FALSE;
     180             :                                 }
     181             : 
     182         988 :                                 if (arg < 0) {
     183         236 :                                         convert_to_string(&argv[currentarg]);
     184         118 :                                         arg = Z_STRLEN(argv[currentarg]);
     185         118 :                                         if (code == 'Z') {
     186             :                                                 /* add one because Z is always NUL-terminated:
     187             :                                                  * pack("Z*", "aa") === "aa\0"
     188             :                                                  * pack("Z2", "aa") === "a\0" */
     189           1 :                                                 arg++;
     190             :                                         }
     191             :                                 }
     192             : 
     193         988 :                                 currentarg++;
     194         988 :                                 break;
     195             : 
     196             :                         /* Use as many args as specified */
     197             :                         case 'q':
     198             :                         case 'Q':
     199             :                         case 'J':
     200             :                         case 'P':
     201             : #if SIZEOF_ZEND_LONG < 8
     202             :                                         efree(formatcodes);
     203             :                                         efree(formatargs);
     204             :                                         php_error_docref(NULL, E_WARNING, "64-bit format codes are not available for 32-bit versions of PHP");
     205             :                                         RETURN_FALSE;
     206             : #endif
     207             :                         case 'c':
     208             :                         case 'C':
     209             :                         case 's':
     210             :                         case 'S':
     211             :                         case 'i':
     212             :                         case 'I':
     213             :                         case 'l':
     214             :                         case 'L':
     215             :                         case 'n':
     216             :                         case 'N':
     217             :                         case 'v':
     218             :                         case 'V':
     219             :                         case 'f':
     220             :                         case 'd':
     221      154919 :                                 if (arg < 0) {
     222           0 :                                         arg = num_args - currentarg;
     223             :                                 }
     224             : 
     225      154919 :                                 currentarg += arg;
     226             : 
     227      154919 :                                 if (currentarg > num_args) {
     228           0 :                                         efree(formatcodes);
     229           0 :                                         efree(formatargs);
     230           0 :                                         php_error_docref(NULL, E_WARNING, "Type %c: too few arguments", code);
     231           0 :                                         RETURN_FALSE;
     232             :                                 }
     233      154919 :                                 break;
     234             : 
     235             :                         default:
     236           0 :                                 efree(formatcodes);
     237           0 :                                 efree(formatargs);
     238           0 :                                 php_error_docref(NULL, E_WARNING, "Type %c: unknown format code", code);
     239           0 :                                 RETURN_FALSE;
     240             :                 }
     241             : 
     242      155908 :                 formatcodes[formatcount] = code;
     243      155908 :                 formatargs[formatcount] = arg;
     244             :         }
     245             : 
     246      153506 :         if (currentarg < num_args) {
     247           0 :                 php_error_docref(NULL, E_WARNING, "%d arguments unused", (num_args - currentarg));
     248             :         }
     249             : 
     250             :         /* Calculate output length and upper bound while processing*/
     251      309414 :         for (i = 0; i < formatcount; i++) {
     252      155908 :             int code = (int) formatcodes[i];
     253      155908 :                 int arg = formatargs[i];
     254             : 
     255      155908 :                 switch ((int) code) {
     256             :                         case 'h':
     257             :                         case 'H':
     258         121 :                                 INC_OUTPUTPOS((arg + (arg % 2)) / 2,1)  /* 4 bit per arg */
     259         121 :                                 break;
     260             : 
     261             :                         case 'a':
     262             :                         case 'A':
     263             :                         case 'Z':
     264             :                         case 'c':
     265             :                         case 'C':
     266             :                         case 'x':
     267      144931 :                                 INC_OUTPUTPOS(arg,1)            /* 8 bit per arg */
     268      144931 :                                 break;
     269             : 
     270             :                         case 's':
     271             :                         case 'S':
     272             :                         case 'n':
     273             :                         case 'v':
     274         102 :                                 INC_OUTPUTPOS(arg,2)            /* 16 bit per arg */
     275         102 :                                 break;
     276             : 
     277             :                         case 'i':
     278             :                         case 'I':
     279           7 :                                 INC_OUTPUTPOS(arg,sizeof(int))
     280           7 :                                 break;
     281             : 
     282             :                         case 'l':
     283             :                         case 'L':
     284             :                         case 'N':
     285             :                         case 'V':
     286       10714 :                                 INC_OUTPUTPOS(arg,4)            /* 32 bit per arg */
     287       10714 :                                 break;
     288             : 
     289             : #if SIZEOF_ZEND_LONG > 4
     290             :                         case 'q':
     291             :                         case 'Q':
     292             :                         case 'J':
     293             :                         case 'P':
     294          20 :                                 INC_OUTPUTPOS(arg,8)            /* 32 bit per arg */
     295          20 :                                 break;
     296             : #endif
     297             : 
     298             :                         case 'f':
     299           0 :                                 INC_OUTPUTPOS(arg,sizeof(float))
     300           0 :                                 break;
     301             : 
     302             :                         case 'd':
     303          13 :                                 INC_OUTPUTPOS(arg,sizeof(double))
     304          13 :                                 break;
     305             : 
     306             :                         case 'X':
     307           0 :                                 outputpos -= arg;
     308             : 
     309           0 :                                 if (outputpos < 0) {
     310           0 :                                         php_error_docref(NULL, E_WARNING, "Type %c: outside of string", code);
     311           0 :                                         outputpos = 0;
     312             :                                 }
     313           0 :                                 break;
     314             : 
     315             :                         case '@':
     316           0 :                                 outputpos = arg;
     317             :                                 break;
     318             :                 }
     319             : 
     320      155908 :                 if (outputsize < outputpos) {
     321      155903 :                         outputsize = outputpos;
     322             :                 }
     323             :         }
     324             : 
     325      307012 :         output = zend_string_alloc(outputsize, 0);
     326      153506 :         outputpos = 0;
     327      153506 :         currentarg = 0;
     328             : 
     329             :         /* Do actual packing */
     330      309414 :         for (i = 0; i < formatcount; i++) {
     331      155908 :             int code = (int) formatcodes[i];
     332      155908 :                 int arg = formatargs[i];
     333             : 
     334      155908 :                 switch ((int) code) {
     335             :                         case 'a':
     336             :                         case 'A':
     337             :                         case 'Z': {
     338         867 :                                 size_t arg_cp = (code != 'Z') ? arg : MAX(0, arg - 1);
     339             : 
     340        1734 :                                 zend_string *str = zval_get_string(&argv[currentarg++]);
     341             : 
     342         867 :                                 memset(&ZSTR_VAL(output)[outputpos], (code == 'a' || code == 'Z') ? '\0' : ' ', arg);
     343         867 :                                 memcpy(&ZSTR_VAL(output)[outputpos], ZSTR_VAL(str),
     344         867 :                                            (ZSTR_LEN(str) < arg_cp) ? ZSTR_LEN(str) : arg_cp);
     345             : 
     346         867 :                                 outputpos += arg;
     347             :                                 zend_string_release(str);
     348         867 :                                 break;
     349             :                         }
     350             : 
     351             :                         case 'h':
     352             :                         case 'H': {
     353         121 :                                 int nibbleshift = (code == 'h') ? 0 : 4;
     354         121 :                                 int first = 1;
     355             : 
     356         242 :                                 zend_string *str = zval_get_string(&argv[currentarg++]);
     357         121 :                                 char *v = ZSTR_VAL(str);
     358             : 
     359         121 :                                 outputpos--;
     360         121 :                                 if ((size_t)arg > ZSTR_LEN(str)) {
     361           0 :                                         php_error_docref(NULL, E_WARNING, "Type %c: not enough characters in string", code);
     362           0 :                                         arg = ZSTR_LEN(str);
     363             :                                 }
     364             : 
     365        5010 :                                 while (arg-- > 0) {
     366        4768 :                                         char n = *v++;
     367             : 
     368        7810 :                                         if (n >= '0' && n <= '9') {
     369        3042 :                                                 n -= '0';
     370        1726 :                                         } else if (n >= 'A' && n <= 'F') {
     371           0 :                                                 n -= ('A' - 10);
     372        3452 :                                         } else if (n >= 'a' && n <= 'f') {
     373        1726 :                                                 n -= ('a' - 10);
     374             :                                         } else {
     375           0 :                                                 php_error_docref(NULL, E_WARNING, "Type %c: illegal hex digit %c", code, n);
     376           0 :                                                 n = 0;
     377             :                                         }
     378             : 
     379        4768 :                                         if (first--) {
     380        2386 :                                                 ZSTR_VAL(output)[++outputpos] = 0;
     381             :                                         } else {
     382        2382 :                                           first = 1;
     383             :                                         }
     384             : 
     385        4768 :                                         ZSTR_VAL(output)[outputpos] |= (n << nibbleshift);
     386        4768 :                                         nibbleshift = (nibbleshift + 4) & 7;
     387             :                                 }
     388             : 
     389         121 :                                 outputpos++;
     390             :                                 zend_string_release(str);
     391         121 :                                 break;
     392             :                         }
     393             : 
     394             :                         case 'c':
     395             :                         case 'C':
     396      781940 :                                 while (arg-- > 0) {
     397      493814 :                                         php_pack(&argv[currentarg++], 1, byte_map, &ZSTR_VAL(output)[outputpos]);
     398      493814 :                                         outputpos++;
     399             :                                 }
     400      144063 :                                 break;
     401             : 
     402             :                         case 's':
     403             :                         case 'S':
     404             :                         case 'n':
     405             :                         case 'v': {
     406         102 :                                 int *map = machine_endian_short_map;
     407             : 
     408         102 :                                 if (code == 'n') {
     409         100 :                                         map = big_endian_short_map;
     410           2 :                                 } else if (code == 'v') {
     411           0 :                                         map = little_endian_short_map;
     412             :                                 }
     413             : 
     414         306 :                                 while (arg-- > 0) {
     415         102 :                                         php_pack(&argv[currentarg++], 2, map, &ZSTR_VAL(output)[outputpos]);
     416         102 :                                         outputpos += 2;
     417             :                                 }
     418         102 :                                 break;
     419             :                         }
     420             : 
     421             :                         case 'i':
     422             :                         case 'I':
     423          21 :                                 while (arg-- > 0) {
     424           7 :                                         php_pack(&argv[currentarg++], sizeof(int), int_map, &ZSTR_VAL(output)[outputpos]);
     425           7 :                                         outputpos += sizeof(int);
     426             :                                 }
     427           7 :                                 break;
     428             : 
     429             :                         case 'l':
     430             :                         case 'L':
     431             :                         case 'N':
     432             :                         case 'V': {
     433       10714 :                                 int *map = machine_endian_long_map;
     434             : 
     435       10714 :                                 if (code == 'N') {
     436        8261 :                                         map = big_endian_long_map;
     437        2453 :                                 } else if (code == 'V') {
     438        2449 :                                         map = little_endian_long_map;
     439             :                                 }
     440             : 
     441       32142 :                                 while (arg-- > 0) {
     442       10714 :                                         php_pack(&argv[currentarg++], 4, map, &ZSTR_VAL(output)[outputpos]);
     443       10714 :                                         outputpos += 4;
     444             :                                 }
     445       10714 :                                 break;
     446             :                         }
     447             : 
     448             : #if SIZEOF_ZEND_LONG > 4
     449             :                         case 'q':
     450             :                         case 'Q':
     451             :                         case 'J':
     452             :                         case 'P': {
     453          20 :                                 int *map = machine_endian_longlong_map;
     454             : 
     455          20 :                                 if (code == 'J') {
     456           5 :                                         map = big_endian_longlong_map;
     457          15 :                                 } else if (code == 'P') {
     458           5 :                                         map = little_endian_longlong_map;
     459             :                                 }
     460             : 
     461          60 :                                 while (arg-- > 0) {
     462          20 :                                         php_pack(&argv[currentarg++], 8, map, &ZSTR_VAL(output)[outputpos]);
     463          20 :                                         outputpos += 8;
     464             :                                 }
     465          20 :                                 break;
     466             :                         }
     467             : #endif
     468             : 
     469             :                         case 'f': {
     470           0 :                                 while (arg-- > 0) {
     471           0 :                                         float v = (float) zval_get_double(&argv[currentarg++]);
     472           0 :                                         memcpy(&ZSTR_VAL(output)[outputpos], &v, sizeof(v));
     473           0 :                                         outputpos += sizeof(v);
     474             :                                 }
     475           0 :                                 break;
     476             :                         }
     477             : 
     478             :                         case 'd': {
     479          39 :                                 while (arg-- > 0) {
     480          26 :                                         double v = (double) zval_get_double(&argv[currentarg++]);
     481          13 :                                         memcpy(&ZSTR_VAL(output)[outputpos], &v, sizeof(v));
     482          13 :                                         outputpos += sizeof(v);
     483             :                                 }
     484          13 :                                 break;
     485             :                         }
     486             : 
     487             :                         case 'x':
     488           1 :                                 memset(&ZSTR_VAL(output)[outputpos], '\0', arg);
     489           1 :                                 outputpos += arg;
     490           1 :                                 break;
     491             : 
     492             :                         case 'X':
     493           0 :                                 outputpos -= arg;
     494             : 
     495           0 :                                 if (outputpos < 0) {
     496           0 :                                         outputpos = 0;
     497             :                                 }
     498           0 :                                 break;
     499             : 
     500             :                         case '@':
     501           0 :                                 if (arg > outputpos) {
     502           0 :                                         memset(&ZSTR_VAL(output)[outputpos], '\0', arg - outputpos);
     503             :                                 }
     504           0 :                                 outputpos = arg;
     505             :                                 break;
     506             :                 }
     507             :         }
     508             : 
     509      153506 :         efree(formatcodes);
     510      153506 :         efree(formatargs);
     511      153506 :         ZSTR_VAL(output)[outputpos] = '\0';
     512      153506 :         ZSTR_LEN(output) = outputpos;
     513      153506 :         RETURN_NEW_STR(output);
     514             : }
     515             : /* }}} */
     516             : 
     517             : /* {{{ php_unpack
     518             :  */
     519          57 : static zend_long php_unpack(char *data, size_t size, int issigned, int *map)
     520             : {
     521             :         zend_long result;
     522          57 :         char *cresult = (char *) &result;
     523             :         size_t i;
     524             : 
     525          57 :         result = issigned ? -1 : 0;
     526             : 
     527         336 :         for (i = 0; i < size; i++) {
     528         279 :                 cresult[map[i]] = *data++;
     529             :         }
     530             : 
     531          57 :         return result;
     532             : }
     533             : /* }}} */
     534             : 
     535             : /* unpack() is based on Perl's unpack(), but is modified a bit from there.
     536             :  * Rather than depending on error-prone ordered lists or syntactically
     537             :  * unpleasant pass-by-reference, we return an object with named parameters
     538             :  * (like *_fetch_object()). Syntax is "f[repeat]name/...", where "f" is the
     539             :  * formatter char (like pack()), "[repeat]" is the optional repeater argument,
     540             :  * and "name" is the name of the variable to use.
     541             :  * Example: "c2chars/nints" will return an object with fields
     542             :  * chars1, chars2, and ints.
     543             :  * Numeric pack types will return numbers, a and A will return strings,
     544             :  * f and d will return doubles.
     545             :  * Implemented formats are Z, A, a, h, H, c, C, s, S, i, I, l, L, n, N, q, Q, J, P, f, d, x, X, @.
     546             :  */
     547             : /* {{{ proto array unpack(string format, string input)
     548             :    Unpack binary string into named array elements according to format argument */
     549        1058 : PHP_FUNCTION(unpack)
     550             : {
     551             :         char *format, *input;
     552             :         zend_string *formatarg, *inputarg;
     553             :         zend_long formatlen, inputpos, inputlen;
     554             :         int i;
     555        1058 :         zend_long offset = 0;
     556             : 
     557        1058 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|l", &formatarg,
     558             :                 &inputarg, &offset) == FAILURE) {
     559           2 :                 return;
     560             :         }
     561             : 
     562        1056 :         format = ZSTR_VAL(formatarg);
     563        1056 :         formatlen = ZSTR_LEN(formatarg);
     564        1056 :         input = ZSTR_VAL(inputarg);
     565        1056 :         inputlen = ZSTR_LEN(inputarg);
     566        1056 :         inputpos = 0;
     567             : 
     568             : 
     569        1056 :         if (offset < 0 || offset > inputlen) {
     570           0 :                 php_error_docref(NULL, E_WARNING, "Offset " ZEND_LONG_FMT " is out of input range" , offset);
     571           0 :                 RETURN_FALSE;
     572             :         }
     573        1056 :         input += offset;
     574        1056 :         inputlen -= offset;
     575             : 
     576        1056 :         array_init(return_value);
     577             : 
     578        3180 :         while (formatlen-- > 0) {
     579        1073 :                 char type = *(format++);
     580             :                 char c;
     581        1073 :                 int arg = 1, argb;
     582             :                 char *name;
     583             :                 int namelen;
     584        1073 :                 int size=0;
     585             : 
     586             :                 /* Handle format arguments if any */
     587        1073 :                 if (formatlen > 0) {
     588        1031 :                         c = *format;
     589             : 
     590        1068 :                         if (c >= '0' && c <= '9') {
     591          37 :                                 arg = atoi(format);
     592             : 
     593         126 :                                 while (formatlen > 0 && *format >= '0' && *format <= '9') {
     594          52 :                                         format++;
     595          52 :                                         formatlen--;
     596             :                                 }
     597         994 :                         } else if (c == '*') {
     598         975 :                                 arg = -1;
     599         975 :                                 format++;
     600         975 :                                 formatlen--;
     601             :                         }
     602             :                 }
     603             : 
     604             :                 /* Get of new value in array */
     605        1073 :                 name = format;
     606        1073 :                 argb = arg;
     607             : 
     608        2234 :                 while (formatlen > 0 && *format != '/') {
     609          88 :                         formatlen--;
     610          88 :                         format++;
     611             :                 }
     612             : 
     613        1073 :                 namelen = format - name;
     614             : 
     615        1073 :                 if (namelen > 200)
     616           0 :                         namelen = 200;
     617             : 
     618        1073 :                 switch ((int) type) {
     619             :                         /* Never use any input */
     620             :                         case 'X':
     621           4 :                                 size = -1;
     622           4 :                                 break;
     623             : 
     624             :                         case '@':
     625           4 :                                 size = 0;
     626           4 :                                 break;
     627             : 
     628             :                         case 'a':
     629             :                         case 'A':
     630             :                         case 'Z':
     631          13 :                                 size = arg;
     632          13 :                                 arg = 1;
     633          13 :                                 break;
     634             : 
     635             :                         case 'h':
     636             :                         case 'H':
     637         985 :                                 size = (arg > 0) ? (arg + (arg % 2)) / 2 : arg;
     638         985 :                                 arg = 1;
     639         985 :                                 break;
     640             : 
     641             :                         /* Use 1 byte of input */
     642             :                         case 'c':
     643             :                         case 'C':
     644             :                         case 'x':
     645           2 :                                 size = 1;
     646           2 :                                 break;
     647             : 
     648             :                         /* Use 2 bytes of input */
     649             :                         case 's':
     650             :                         case 'S':
     651             :                         case 'n':
     652             :                         case 'v':
     653          10 :                                 size = 2;
     654          10 :                                 break;
     655             : 
     656             :                         /* Use sizeof(int) bytes of input */
     657             :                         case 'i':
     658             :                         case 'I':
     659           1 :                                 size = sizeof(int);
     660           1 :                                 break;
     661             : 
     662             :                         /* Use 4 bytes of input */
     663             :                         case 'l':
     664             :                         case 'L':
     665             :                         case 'N':
     666             :                         case 'V':
     667          19 :                                 size = 4;
     668          19 :                                 break;
     669             : 
     670             :                         /* Use 8 bytes of input */
     671             :                         case 'q':
     672             :                         case 'Q':
     673             :                         case 'J':
     674             :                         case 'P':
     675             : #if SIZEOF_ZEND_LONG > 4
     676          20 :                                 size = 8;
     677          20 :                                 break;
     678             : #else
     679             :                                 php_error_docref(NULL, E_WARNING, "64-bit format codes are not available for 32-bit versions of PHP");
     680             :                                 zval_dtor(return_value);
     681             :                                 RETURN_FALSE;
     682             : #endif
     683             : 
     684             :                         /* Use sizeof(float) bytes of input */
     685             :                         case 'f':
     686           0 :                                 size = sizeof(float);
     687           0 :                                 break;
     688             : 
     689             :                         /* Use sizeof(double) bytes of input */
     690             :                         case 'd':
     691          13 :                                 size = sizeof(double);
     692          13 :                                 break;
     693             : 
     694             :                         default:
     695           2 :                                 php_error_docref(NULL, E_WARNING, "Invalid format type %c", type);
     696             :                                 zval_dtor(return_value);
     697           2 :                                 RETURN_FALSE;
     698             :                                 break;
     699             :                 }
     700             : 
     701        1071 :                 if (size != 0 && size != -1 && size < 0) {
     702           1 :                         php_error_docref(NULL, E_WARNING, "Type %c: integer overflow", type);
     703             :                         zval_dtor(return_value);
     704           1 :                         RETURN_FALSE;
     705             :                 }
     706             : 
     707             :                 /* Do actual unpacking */
     708        2152 :                 for (i = 0; i != arg; i++ ) {
     709             :                         /* Space for name + number, safe as namelen is ensured <= 200 */
     710             :                         char n[256];
     711             : 
     712        2147 :                         if (arg != 1 || namelen == 0) {
     713             :                                 /* Need to add element number to name */
     714        1062 :                                 snprintf(n, sizeof(n), "%.*s%d", namelen, name, i + 1);
     715             :                         } else {
     716             :                                 /* Truncate name to next format code or end of string */
     717          23 :                                 snprintf(n, sizeof(n), "%.*s", namelen, name);
     718             :                         }
     719             : 
     720        1085 :                         if (size != 0 && size != -1 && INT_MAX - size + 1 < inputpos) {
     721           0 :                                 php_error_docref(NULL, E_WARNING, "Type %c: integer overflow", type);
     722             :                                 zval_dtor(return_value);
     723           0 :                                 RETURN_FALSE;
     724             :                         }
     725             : 
     726        1085 :                         if ((inputpos + size) <= inputlen) {
     727        1082 :                                 switch ((int) type) {
     728             :                                         case 'a': {
     729             :                                                 /* a will not strip any trailing whitespace or null padding */
     730           3 :                                                 zend_long len = inputlen - inputpos;    /* Remaining string */
     731             : 
     732             :                                                 /* If size was given take minimum of len and size */
     733           3 :                                                 if ((size >= 0) && (len > size)) {
     734           1 :                                                         len = size;
     735             :                                                 }
     736             : 
     737           3 :                                                 size = len;
     738             : 
     739           3 :                                                 add_assoc_stringl(return_value, n, &input[inputpos], len);
     740           3 :                                                 break;
     741             :                                         }
     742             :                                         case 'A': {
     743             :                                                 /* A will strip any trailing whitespace */
     744           2 :                                                 char padn = '\0'; char pads = ' '; char padt = '\t'; char padc = '\r'; char padl = '\n';
     745           2 :                                                 zend_long len = inputlen - inputpos;    /* Remaining string */
     746             : 
     747             :                                                 /* If size was given take minimum of len and size */
     748           2 :                                                 if ((size >= 0) && (len > size)) {
     749           1 :                                                         len = size;
     750             :                                                 }
     751             : 
     752           2 :                                                 size = len;
     753             : 
     754             :                                                 /* Remove trailing white space and nulls chars from unpacked data */
     755          10 :                                                 while (--len >= 0) {
     756          26 :                                                         if (input[inputpos + len] != padn
     757           6 :                                                                 && input[inputpos + len] != pads
     758           5 :                                                                 && input[inputpos + len] != padt
     759           4 :                                                                 && input[inputpos + len] != padc
     760           3 :                                                                 && input[inputpos + len] != padl
     761             :                                                         )
     762           2 :                                                                 break;
     763             :                                                 }
     764             : 
     765           2 :                                                 add_assoc_stringl(return_value, n, &input[inputpos], len + 1);
     766           2 :                                                 break;
     767             :                                         }
     768             :                                         /* New option added for Z to remain in-line with the Perl implementation */
     769             :                                         case 'Z': {
     770             :                                                 /* Z will strip everything after the first null character */
     771           6 :                                                 char pad = '\0';
     772             :                                                 zend_long s,
     773           6 :                                                          len = inputlen - inputpos;     /* Remaining string */
     774             : 
     775             :                                                 /* If size was given take minimum of len and size */
     776           6 :                                                 if ((size >= 0) && (len > size)) {
     777           3 :                                                         len = size;
     778             :                                                 }
     779             : 
     780           6 :                                                 size = len;
     781             : 
     782             :                                                 /* Remove everything after the first null */
     783          17 :                                                 for (s=0 ; s < len ; s++) {
     784          15 :                                                         if (input[inputpos + s] == pad)
     785           4 :                                                                 break;
     786             :                                                 }
     787           6 :                                                 len = s;
     788             : 
     789           6 :                                                 add_assoc_stringl(return_value, n, &input[inputpos], len);
     790           6 :                                                 break;
     791             :                                         }
     792             : 
     793             : 
     794             :                                         case 'h':
     795             :                                         case 'H': {
     796         984 :                                                 zend_long len = (inputlen - inputpos) * 2;      /* Remaining */
     797         984 :                                                 int nibbleshift = (type == 'h') ? 0 : 4;
     798         984 :                                                 int first = 1;
     799             :                                                 char *buf;
     800             :                                                 zend_long ipos, opos;
     801             : 
     802             :                                                 /* If size was given take minimum of len and size */
     803         984 :                                                 if (size >= 0 && len > (size * 2)) {
     804           0 :                                                         len = size * 2;
     805             :                                                 }
     806             : 
     807         984 :                                                 if (len > 0 && argb > 0) {
     808          13 :                                                         len -= argb % 2;
     809             :                                                 }
     810             : 
     811         984 :                                                 buf = emalloc(len + 1);
     812             : 
     813        5460 :                                                 for (ipos = opos = 0; opos < len; opos++) {
     814        4476 :                                                         char cc = (input[inputpos + ipos] >> nibbleshift) & 0xf;
     815             : 
     816        4476 :                                                         if (cc < 10) {
     817        3261 :                                                                 cc += '0';
     818             :                                                         } else {
     819        1215 :                                                                 cc += 'a' - 10;
     820             :                                                         }
     821             : 
     822        4476 :                                                         buf[opos] = cc;
     823        4476 :                                                         nibbleshift = (nibbleshift + 4) & 7;
     824             : 
     825        4476 :                                                         if (first-- == 0) {
     826        2237 :                                                                 ipos++;
     827        2237 :                                                                 first = 1;
     828             :                                                         }
     829             :                                                 }
     830             : 
     831         984 :                                                 buf[len] = '\0';
     832         984 :                                                 add_assoc_stringl(return_value, n, buf, len);
     833         984 :                                                 efree(buf);
     834         984 :                                                 break;
     835             :                                         }
     836             : 
     837             :                                         case 'c':
     838             :                                         case 'C': {
     839           3 :                                                 int issigned = (type == 'c') ? (input[inputpos] & 0x80) : 0;
     840           3 :                                                 zend_long v = php_unpack(&input[inputpos], 1, issigned, byte_map);
     841           3 :                                                 add_assoc_long(return_value, n, v);
     842           3 :                                                 break;
     843             :                                         }
     844             : 
     845             :                                         case 's':
     846             :                                         case 'S':
     847             :                                         case 'n':
     848             :                                         case 'v': {
     849             :                                                 zend_long v;
     850          10 :                                                 int issigned = 0;
     851          10 :                                                 int *map = machine_endian_short_map;
     852             : 
     853          10 :                                                 if (type == 's') {
     854           0 :                                                         issigned = input[inputpos + (machine_little_endian ? 1 : 0)] & 0x80;
     855          10 :                                                 } else if (type == 'n') {
     856           9 :                                                         map = big_endian_short_map;
     857           1 :                                                 } else if (type == 'v') {
     858           1 :                                                         map = little_endian_short_map;
     859             :                                                 }
     860             : 
     861          10 :                                                 v = php_unpack(&input[inputpos], 2, issigned, map);
     862          10 :                                                 add_assoc_long(return_value, n, v);
     863          10 :                                                 break;
     864             :                                         }
     865             : 
     866             :                                         case 'i':
     867             :                                         case 'I': {
     868             :                                                 zend_long v;
     869           1 :                                                 int issigned = 0;
     870             : 
     871           1 :                                                 if (type == 'i') {
     872           0 :                                                         issigned = input[inputpos + (machine_little_endian ? (sizeof(int) - 1) : 0)] & 0x80;
     873             :                                                 }
     874             : 
     875           1 :                                                 v = php_unpack(&input[inputpos], sizeof(int), issigned, int_map);
     876           1 :                                                 add_assoc_long(return_value, n, v);
     877           1 :                                                 break;
     878             :                                         }
     879             : 
     880             :                                         case 'l':
     881             :                                         case 'L':
     882             :                                         case 'N':
     883             :                                         case 'V': {
     884          23 :                                                 int issigned = 0;
     885          23 :                                                 int *map = machine_endian_long_map;
     886          23 :                                                 zend_long v = 0;
     887             : 
     888          28 :                                                 if (type == 'l' || type == 'L') {
     889           5 :                                                         issigned = input[inputpos + (machine_little_endian ? 3 : 0)] & 0x80;
     890          18 :                                                 } else if (type == 'N') {
     891           8 :                                                         issigned = input[inputpos] & 0x80;
     892           8 :                                                         map = big_endian_long_map;
     893          10 :                                                 } else if (type == 'V') {
     894          10 :                                                         issigned = input[inputpos + 3] & 0x80;
     895          10 :                                                         map = little_endian_long_map;
     896             :                                                 }
     897             : 
     898          23 :                                                 if (SIZEOF_ZEND_LONG > 4 && issigned) {
     899           2 :                                                         v = ~INT_MAX;
     900             :                                                 }
     901             : 
     902          23 :                                                 v |= php_unpack(&input[inputpos], 4, issigned, map);
     903             :                                                 if (SIZEOF_ZEND_LONG > 4) {
     904          23 :                                                         if (type == 'l') {
     905           5 :                                                                 v = (signed int) v;
     906             :                                                         } else {
     907          18 :                                                                 v = (unsigned int) v;
     908             :                                                         }
     909             :                                                 }
     910          23 :                                                 add_assoc_long(return_value, n, v);
     911          23 :                                                 break;
     912             :                                         }
     913             : 
     914             : #if SIZEOF_ZEND_LONG > 4
     915             :                                         case 'q':
     916             :                                         case 'Q':
     917             :                                         case 'J':
     918             :                                         case 'P': {
     919          20 :                                                 int issigned = 0;
     920          20 :                                                 int *map = machine_endian_longlong_map;
     921          20 :                                                 zend_long v = 0;
     922             : 
     923          30 :                                                 if (type == 'q' || type == 'Q') {
     924          10 :                                                         issigned = input[inputpos + (machine_little_endian ? 7 : 0)] & 0x80;
     925          10 :                                                 } else if (type == 'J') {
     926           5 :                                                         issigned = input[inputpos] & 0x80;
     927           5 :                                                         map = big_endian_longlong_map;
     928           5 :                                                 } else if (type == 'P') {
     929           5 :                                                         issigned = input[inputpos + 7] & 0x80;
     930           5 :                                                         map = little_endian_longlong_map;
     931             :                                                 }
     932             : 
     933          20 :                                                 v = php_unpack(&input[inputpos], 8, issigned, map);
     934             : 
     935          20 :                                                 if (type == 'q') {
     936           5 :                                                         v = (zend_long) v;
     937             :                                                 } else {
     938          15 :                                                         v = (zend_ulong) v;
     939             :                                                 }
     940             : 
     941          20 :                                                 add_assoc_long(return_value, n, v);
     942          20 :                                                 break;
     943             :                                         }
     944             : #endif
     945             : 
     946             :                                         case 'f': {
     947             :                                                 float v;
     948             : 
     949           0 :                                                 memcpy(&v, &input[inputpos], sizeof(float));
     950           0 :                                                 add_assoc_double(return_value, n, (double)v);
     951           0 :                                                 break;
     952             :                                         }
     953             : 
     954             :                                         case 'd': {
     955             :                                                 double v;
     956             : 
     957          13 :                                                 memcpy(&v, &input[inputpos], sizeof(double));
     958          13 :                                                 add_assoc_double(return_value, n, v);
     959          13 :                                                 break;
     960             :                                         }
     961             : 
     962             :                                         case 'x':
     963             :                                                 /* Do nothing with input, just skip it */
     964           0 :                                                 break;
     965             : 
     966             :                                         case 'X':
     967          13 :                                                 if (inputpos < size) {
     968           0 :                                                         inputpos = -size;
     969           0 :                                                         i = arg - 1;            /* Break out of for loop */
     970             : 
     971           0 :                                                         if (arg >= 0) {
     972           0 :                                                                 php_error_docref(NULL, E_WARNING, "Type %c: outside of string", type);
     973             :                                                         }
     974             :                                                 }
     975          13 :                                                 break;
     976             : 
     977             :                                         case '@':
     978           4 :                                                 if (arg <= inputlen) {
     979           4 :                                                         inputpos = arg;
     980             :                                                 } else {
     981           0 :                                                         php_error_docref(NULL, E_WARNING, "Type %c: outside of string", type);
     982             :                                                 }
     983             : 
     984           4 :                                                 i = arg - 1;    /* Done, break out of for loop */
     985             :                                                 break;
     986             :                                 }
     987             : 
     988        1082 :                                 inputpos += size;
     989        1082 :                                 if (inputpos < 0) {
     990         971 :                                         if (size != -1) { /* only print warning if not working with * */
     991           0 :                                                 php_error_docref(NULL, E_WARNING, "Type %c: outside of string", type);
     992             :                                         }
     993         971 :                                         inputpos = 0;
     994             :                                 }
     995           3 :                         } else if (arg < 0) {
     996             :                                 /* Reached end of input for '*' repeater */
     997           1 :                                 break;
     998             :                         } else {
     999           2 :                                 php_error_docref(NULL, E_WARNING, "Type %c: not enough input, need %d, have " ZEND_LONG_FMT, type, size, inputlen - inputpos);
    1000             :                                 zval_dtor(return_value);
    1001           2 :                                 RETURN_FALSE;
    1002             :                         }
    1003             :                 }
    1004             : 
    1005        1068 :                 if (formatlen > 0) {
    1006          17 :                         formatlen--;    /* Skip '/' separator, does no harm if inputlen == 0 */
    1007          17 :                         format++;
    1008             :                 }
    1009             :         }
    1010             : }
    1011             : /* }}} */
    1012             : 
    1013             : /* {{{ PHP_MINIT_FUNCTION
    1014             :  */
    1015       23950 : PHP_MINIT_FUNCTION(pack)
    1016             : {
    1017       23950 :         int machine_endian_check = 1;
    1018             :         int i;
    1019             : 
    1020       23950 :         machine_little_endian = ((char *)&machine_endian_check)[0];
    1021             : 
    1022       23950 :         if (machine_little_endian) {
    1023             :                 /* Where to get lo to hi bytes from */
    1024       23950 :                 byte_map[0] = 0;
    1025             : 
    1026      119750 :                 for (i = 0; i < (int)sizeof(int); i++) {
    1027       95800 :                         int_map[i] = i;
    1028             :                 }
    1029             : 
    1030       23950 :                 machine_endian_short_map[0] = 0;
    1031       23950 :                 machine_endian_short_map[1] = 1;
    1032       23950 :                 big_endian_short_map[0] = 1;
    1033       23950 :                 big_endian_short_map[1] = 0;
    1034       23950 :                 little_endian_short_map[0] = 0;
    1035       23950 :                 little_endian_short_map[1] = 1;
    1036             : 
    1037       23950 :                 machine_endian_long_map[0] = 0;
    1038       23950 :                 machine_endian_long_map[1] = 1;
    1039       23950 :                 machine_endian_long_map[2] = 2;
    1040       23950 :                 machine_endian_long_map[3] = 3;
    1041       23950 :                 big_endian_long_map[0] = 3;
    1042       23950 :                 big_endian_long_map[1] = 2;
    1043       23950 :                 big_endian_long_map[2] = 1;
    1044       23950 :                 big_endian_long_map[3] = 0;
    1045       23950 :                 little_endian_long_map[0] = 0;
    1046       23950 :                 little_endian_long_map[1] = 1;
    1047       23950 :                 little_endian_long_map[2] = 2;
    1048       23950 :                 little_endian_long_map[3] = 3;
    1049             : 
    1050             : #if SIZEOF_ZEND_LONG > 4
    1051       23950 :                 machine_endian_longlong_map[0] = 0;
    1052       23950 :                 machine_endian_longlong_map[1] = 1;
    1053       23950 :                 machine_endian_longlong_map[2] = 2;
    1054       23950 :                 machine_endian_longlong_map[3] = 3;
    1055       23950 :                 machine_endian_longlong_map[4] = 4;
    1056       23950 :                 machine_endian_longlong_map[5] = 5;
    1057       23950 :                 machine_endian_longlong_map[6] = 6;
    1058       23950 :                 machine_endian_longlong_map[7] = 7;
    1059       23950 :                 big_endian_longlong_map[0] = 7;
    1060       23950 :                 big_endian_longlong_map[1] = 6;
    1061       23950 :                 big_endian_longlong_map[2] = 5;
    1062       23950 :                 big_endian_longlong_map[3] = 4;
    1063       23950 :                 big_endian_longlong_map[4] = 3;
    1064       23950 :                 big_endian_longlong_map[5] = 2;
    1065       23950 :                 big_endian_longlong_map[6] = 1;
    1066       23950 :                 big_endian_longlong_map[7] = 0;
    1067       23950 :                 little_endian_longlong_map[0] = 0;
    1068       23950 :                 little_endian_longlong_map[1] = 1;
    1069       23950 :                 little_endian_longlong_map[2] = 2;
    1070       23950 :                 little_endian_longlong_map[3] = 3;
    1071       23950 :                 little_endian_longlong_map[4] = 4;
    1072       23950 :                 little_endian_longlong_map[5] = 5;
    1073       23950 :                 little_endian_longlong_map[6] = 6;
    1074       23950 :                 little_endian_longlong_map[7] = 7;
    1075             : #endif
    1076             :         }
    1077             :         else {
    1078             :                 zval val;
    1079           0 :                 int size = sizeof(Z_LVAL(val));
    1080           0 :                 Z_LVAL(val)=0; /*silence a warning*/
    1081             : 
    1082             :                 /* Where to get hi to lo bytes from */
    1083           0 :                 byte_map[0] = size - 1;
    1084             : 
    1085           0 :                 for (i = 0; i < (int)sizeof(int); i++) {
    1086           0 :                         int_map[i] = size - (sizeof(int) - i);
    1087             :                 }
    1088             : 
    1089           0 :                 machine_endian_short_map[0] = size - 2;
    1090           0 :                 machine_endian_short_map[1] = size - 1;
    1091           0 :                 big_endian_short_map[0] = size - 2;
    1092           0 :                 big_endian_short_map[1] = size - 1;
    1093           0 :                 little_endian_short_map[0] = size - 1;
    1094           0 :                 little_endian_short_map[1] = size - 2;
    1095             : 
    1096           0 :                 machine_endian_long_map[0] = size - 4;
    1097           0 :                 machine_endian_long_map[1] = size - 3;
    1098           0 :                 machine_endian_long_map[2] = size - 2;
    1099           0 :                 machine_endian_long_map[3] = size - 1;
    1100           0 :                 big_endian_long_map[0] = size - 4;
    1101           0 :                 big_endian_long_map[1] = size - 3;
    1102           0 :                 big_endian_long_map[2] = size - 2;
    1103           0 :                 big_endian_long_map[3] = size - 1;
    1104           0 :                 little_endian_long_map[0] = size - 1;
    1105           0 :                 little_endian_long_map[1] = size - 2;
    1106           0 :                 little_endian_long_map[2] = size - 3;
    1107           0 :                 little_endian_long_map[3] = size - 4;
    1108             : 
    1109             : #if SIZEOF_ZEND_LONG > 4
    1110           0 :                 machine_endian_longlong_map[0] = size - 8;
    1111           0 :                 machine_endian_longlong_map[1] = size - 7;
    1112           0 :                 machine_endian_longlong_map[2] = size - 6;
    1113           0 :                 machine_endian_longlong_map[3] = size - 5;
    1114           0 :                 machine_endian_longlong_map[4] = size - 4;
    1115           0 :                 machine_endian_longlong_map[5] = size - 3;
    1116           0 :                 machine_endian_longlong_map[6] = size - 2;
    1117           0 :                 machine_endian_longlong_map[7] = size - 1;
    1118           0 :                 big_endian_longlong_map[0] = size - 8;
    1119           0 :                 big_endian_longlong_map[1] = size - 7;
    1120           0 :                 big_endian_longlong_map[2] = size - 6;
    1121           0 :                 big_endian_longlong_map[3] = size - 5;
    1122           0 :                 big_endian_longlong_map[4] = size - 4;
    1123           0 :                 big_endian_longlong_map[5] = size - 3;
    1124           0 :                 big_endian_longlong_map[6] = size - 2;
    1125           0 :                 big_endian_longlong_map[7] = size - 1;
    1126           0 :                 little_endian_longlong_map[0] = size - 1;
    1127           0 :                 little_endian_longlong_map[1] = size - 2;
    1128           0 :                 little_endian_longlong_map[2] = size - 3;
    1129           0 :                 little_endian_longlong_map[3] = size - 4;
    1130           0 :                 little_endian_longlong_map[4] = size - 5;
    1131           0 :                 little_endian_longlong_map[5] = size - 6;
    1132           0 :                 little_endian_longlong_map[6] = size - 7;
    1133           0 :                 little_endian_longlong_map[7] = size - 8;
    1134             : #endif
    1135             :         }
    1136             : 
    1137       23950 :         return SUCCESS;
    1138             : }
    1139             : /* }}} */
    1140             : 
    1141             : /*
    1142             :  * Local variables:
    1143             :  * tab-width: 4
    1144             :  * c-basic-offset: 4
    1145             :  * End:
    1146             :  * vim600: noet sw=4 ts=4 fdm=marker
    1147             :  * vim<600: noet sw=4 ts=4
    1148             :  */

Generated by: LCOV version 1.10

Generated at Tue, 27 Sep 2016 10:26:08 +0000 (2 days ago)

Copyright © 2005-2016 The PHP Group
All rights reserved.