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/dba/libflatfile - flatfile.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 124 158 78.5 %
Date: 2014-07-23 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2013 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             :    | Authors: Marcus Boerger <helly@php.net>                              |
      16             :    | based on ext/db/db.c by:                                             |
      17             :    |          Rasmus Lerdorf <rasmus@php.net>                             |
      18             :    |          Jim Winstead <jimw@php.net>                                 |
      19             :    +----------------------------------------------------------------------+
      20             :  */
      21             : 
      22             : /* $Id: e33fd9ea7039be4aec7f2b7ec0f0e24da46e4c55 $ */
      23             : 
      24             : #ifdef HAVE_CONFIG_H
      25             : #include "config.h"
      26             : #endif
      27             : 
      28             : #include "php.h"
      29             : #include "php_globals.h"
      30             : #include "safe_mode.h"
      31             : 
      32             : #include <stdlib.h>
      33             : #include <string.h>
      34             : #include <errno.h>
      35             : #if HAVE_UNISTD_H
      36             : #include <unistd.h>
      37             : #endif
      38             : 
      39             : #include "flatfile.h"
      40             : 
      41             : #define FLATFILE_BLOCK_SIZE 1024
      42             : 
      43             : /*
      44             :  * ret = -1 means that database was opened for read-only
      45             :  * ret = 0  success
      46             :  * ret = 1  key already exists - nothing done
      47             :  */
      48             : 
      49             : /* {{{ flatfile_store
      50             :  */
      51          66 : int flatfile_store(flatfile *dba, datum key_datum, datum value_datum, int mode TSRMLS_DC) {
      52          66 :         if (mode == FLATFILE_INSERT) {
      53          57 :                 if (flatfile_findkey(dba, key_datum TSRMLS_CC)) {
      54           4 :                         return 1;
      55             :                 }
      56          53 :                 php_stream_seek(dba->fp, 0L, SEEK_END);
      57          53 :                 php_stream_printf(dba->fp TSRMLS_CC, "%zu\n", key_datum.dsize);
      58          53 :                 php_stream_flush(dba->fp);
      59          53 :                 if (php_stream_write(dba->fp, key_datum.dptr, key_datum.dsize) < key_datum.dsize) {
      60           0 :                         return -1;
      61             :                 }
      62          53 :                 php_stream_printf(dba->fp TSRMLS_CC, "%zu\n", value_datum.dsize);
      63          53 :                 php_stream_flush(dba->fp);
      64          53 :                 if (php_stream_write(dba->fp, value_datum.dptr, value_datum.dsize) < value_datum.dsize) {
      65           0 :                         return -1;
      66             :                 }
      67             :         } else { /* FLATFILE_REPLACE */
      68           9 :                 flatfile_delete(dba, key_datum TSRMLS_CC);
      69           9 :                 php_stream_printf(dba->fp TSRMLS_CC, "%zu\n", key_datum.dsize);
      70           9 :                 php_stream_flush(dba->fp);
      71           9 :                 if (php_stream_write(dba->fp, key_datum.dptr, key_datum.dsize) < key_datum.dsize) {
      72           0 :                         return -1;
      73             :                 }
      74           9 :                 php_stream_printf(dba->fp TSRMLS_CC, "%zu\n", value_datum.dsize);
      75           9 :                 if (php_stream_write(dba->fp, value_datum.dptr, value_datum.dsize) < value_datum.dsize) {
      76           0 :                         return -1;
      77             :                 }
      78             :         }
      79             : 
      80          62 :         php_stream_flush(dba->fp);
      81          62 :         return 0;
      82             : }
      83             : /* }}} */
      84             : 
      85             : /* {{{ flatfile_fetch
      86             :  */
      87          74 : datum flatfile_fetch(flatfile *dba, datum key_datum TSRMLS_DC) {
      88          74 :         datum value_datum = {NULL, 0};
      89             :         char buf[16];
      90             : 
      91          74 :         if (flatfile_findkey(dba, key_datum TSRMLS_CC)) {
      92          64 :                 if (php_stream_gets(dba->fp, buf, sizeof(buf))) {
      93          64 :                         value_datum.dsize = atoi(buf);
      94          64 :                         value_datum.dptr = safe_emalloc(value_datum.dsize, 1, 1);
      95          64 :                         value_datum.dsize = php_stream_read(dba->fp, value_datum.dptr, value_datum.dsize);
      96             :                 } else {
      97           0 :                         value_datum.dptr = NULL;
      98           0 :                         value_datum.dsize = 0;
      99             :                 }
     100             :         }
     101          74 :         return value_datum;
     102             : }
     103             : /* }}} */
     104             : 
     105             : /* {{{ flatfile_delete
     106             :  */
     107          23 : int flatfile_delete(flatfile *dba, datum key_datum TSRMLS_DC) {
     108          23 :         char *key = key_datum.dptr;
     109          23 :         size_t size = key_datum.dsize;
     110          23 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     111          23 :         char *buf = emalloc(buf_size);
     112             :         size_t num;
     113             :         size_t pos;
     114             : 
     115          23 :         php_stream_rewind(dba->fp);
     116          92 :         while(!php_stream_eof(dba->fp)) {
     117             :                 /* read in the length of the key name */
     118          69 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     119           0 :                         break;
     120             :                 }
     121          69 :                 num = atoi(buf);
     122          69 :                 if (num >= buf_size) {
     123           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     124           0 :                         buf = erealloc(buf, buf_size);
     125             :                 }
     126          69 :                 pos = php_stream_tell(dba->fp);
     127             : 
     128             :                 /* read in the key name */
     129          69 :                 num = php_stream_read(dba->fp, buf, num);
     130          69 :                 if (num < 0)  {
     131             :                         break;
     132             :                 }
     133             : 
     134          69 :                 if (size == num && !memcmp(buf, key, size)) {
     135          23 :                         php_stream_seek(dba->fp, pos, SEEK_SET);
     136          23 :                         php_stream_putc(dba->fp, 0);
     137          23 :                         php_stream_flush(dba->fp);
     138          23 :                         php_stream_seek(dba->fp, 0L, SEEK_END);
     139          23 :                         efree(buf);
     140          23 :                         return SUCCESS;
     141             :                 }       
     142             : 
     143             :                 /* read in the length of the value */
     144          46 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     145           0 :                         break;
     146             :                 }
     147          46 :                 num = atoi(buf);
     148          46 :                 if (num >= buf_size) {
     149           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     150           0 :                         buf = erealloc(buf, buf_size);
     151             :                 }
     152             :                 /* read in the value */
     153          46 :                 num = php_stream_read(dba->fp, buf, num);
     154          46 :                 if (num < 0) {
     155             :                         break;
     156             :                 }
     157             :         }
     158           0 :         efree(buf);
     159           0 :         return FAILURE;
     160             : }       
     161             : /* }}} */
     162             : 
     163             : /* {{{ flatfile_findkey
     164             :  */
     165         131 : int flatfile_findkey(flatfile *dba, datum key_datum TSRMLS_DC) {
     166         131 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     167         131 :         char *buf = emalloc(buf_size);
     168             :         size_t num;
     169         131 :         int ret=0;
     170         131 :         void *key = key_datum.dptr;
     171         131 :         size_t size = key_datum.dsize;
     172             : 
     173         131 :         php_stream_rewind(dba->fp);
     174         663 :         while (!php_stream_eof(dba->fp)) {
     175         532 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     176          63 :                         break;
     177             :                 }
     178         469 :                 num = atoi(buf);
     179         469 :                 if (num >= buf_size) {
     180           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     181           0 :                         buf = erealloc(buf, buf_size);
     182             :                 }
     183         469 :                 num = php_stream_read(dba->fp, buf, num);
     184         469 :                 if (num < 0) {
     185             :                         break;
     186             :                 }
     187         469 :                 if (size == num) {
     188         355 :                         if (!memcmp(buf, key, size)) {
     189          68 :                                 ret = 1;
     190          68 :                                 break;
     191             :                         }
     192             :                 }       
     193         401 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     194           0 :                         break;
     195             :                 }
     196         401 :                 num = atoi(buf);
     197         401 :                 if (num >= buf_size) {
     198           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     199           0 :                         buf = erealloc(buf, buf_size);
     200             :                 }
     201         401 :                 num = php_stream_read(dba->fp, buf, num);
     202         401 :                 if (num < 0) {
     203             :                         break;
     204             :                 }
     205             :         }
     206         131 :         efree(buf);
     207         131 :         return ret;
     208             : }
     209             : /* }}} */
     210             : 
     211             : /* {{{ flatfile_firstkey
     212             :  */
     213          13 : datum flatfile_firstkey(flatfile *dba TSRMLS_DC) {
     214             :         datum res;
     215             :         size_t num;
     216          13 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     217          13 :         char *buf = emalloc(buf_size);
     218             : 
     219          13 :         php_stream_rewind(dba->fp);
     220          47 :         while(!php_stream_eof(dba->fp)) {
     221          34 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     222           0 :                         break;
     223             :                 }
     224          34 :                 num = atoi(buf);
     225          34 :                 if (num >= buf_size) {
     226           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     227           0 :                         buf = erealloc(buf, buf_size);
     228             :                 }
     229          34 :                 num = php_stream_read(dba->fp, buf, num);
     230          34 :                 if (num < 0) {
     231             :                         break;
     232             :                 }
     233          34 :                 if (*(buf) != 0) {
     234          13 :                         dba->CurrentFlatFilePos = php_stream_tell(dba->fp);
     235          13 :                         res.dptr = buf;
     236          13 :                         res.dsize = num;
     237          13 :                         return res;
     238             :                 }
     239          21 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     240           0 :                         break;
     241             :                 }
     242          21 :                 num = atoi(buf);
     243          21 :                 if (num >= buf_size) {
     244           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     245           0 :                         buf = erealloc(buf, buf_size);
     246             :                 }
     247          21 :                 num = php_stream_read(dba->fp, buf, num);
     248          21 :                 if (num < 0) {
     249             :                         break;
     250             :                 }
     251             :         }
     252           0 :         efree(buf);
     253           0 :         res.dptr = NULL;
     254           0 :         res.dsize = 0;
     255           0 :         return res;
     256             : }
     257             : /* }}} */
     258             : 
     259             : /* {{{ flatfile_nextkey
     260             :  */
     261          42 : datum flatfile_nextkey(flatfile *dba TSRMLS_DC) {
     262             :         datum res;
     263             :         size_t num;
     264          42 :         size_t buf_size = FLATFILE_BLOCK_SIZE;
     265          42 :         char *buf = emalloc(buf_size);
     266             : 
     267          42 :         php_stream_seek(dba->fp, dba->CurrentFlatFilePos, SEEK_SET);
     268          42 :         while(!php_stream_eof(dba->fp)) {
     269          51 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     270           0 :                         break;
     271             :                 }
     272          51 :                 num = atoi(buf);
     273          51 :                 if (num >= buf_size) {
     274           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     275           0 :                         buf = erealloc(buf, buf_size);
     276             :                 }
     277          51 :                 num = php_stream_read(dba->fp, buf, num);
     278          51 :                 if (num < 0)  {
     279             :                         break;
     280             :                 }
     281          51 :                 if (!php_stream_gets(dba->fp, buf, 15)) {
     282          13 :                         break;
     283             :                 }
     284          38 :                 num = atoi(buf);
     285          38 :                 if (num >= buf_size) {
     286           0 :                         buf_size = num + FLATFILE_BLOCK_SIZE;
     287           0 :                         buf = erealloc(buf, buf_size);
     288             :                 }
     289          38 :                 num = php_stream_read(dba->fp, buf, num);
     290          38 :                 if (num < 0) {
     291             :                         break;
     292             :                 }
     293          38 :                 if (*(buf)!=0) {
     294          29 :                         dba->CurrentFlatFilePos = php_stream_tell(dba->fp);
     295          29 :                         res.dptr = buf;
     296          29 :                         res.dsize = num;
     297          29 :                         return res;
     298             :                 }
     299             :         }
     300          13 :         efree(buf);
     301          13 :         res.dptr = NULL;
     302          13 :         res.dsize = 0;
     303          13 :         return res;
     304             : }       
     305             : /* }}} */
     306             : 
     307             : /* {{{ flatfile_version */
     308           2 : char *flatfile_version() 
     309             : {
     310           2 :         return "1.0, $Id: e33fd9ea7039be4aec7f2b7ec0f0e24da46e4c55 $";
     311             : }
     312             : /* }}} */ 
     313             : 
     314             : /*
     315             :  * Local variables:
     316             :  * tab-width: 4
     317             :  * c-basic-offset: 4
     318             :  * End:
     319             :  * vim600: sw=4 ts=4 fdm=marker
     320             :  * vim<600: sw=4 ts=4
     321             :  */

Generated by: LCOV version 1.10

Generated at Wed, 23 Jul 2014 19:58:30 +0000 (8 hours ago)

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