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/interbase - ibase_service.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 54 268 20.1 %
Date: 2017-07-21 Functions: 1 16 6.2 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2017 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: Ard Biesheuvel <a.k.biesheuvel@its.tudelft.nl>              |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : 
      19             : #ifdef HAVE_CONFIG_H
      20             : #include "config.h"
      21             : #endif
      22             : 
      23             : #include "php.h"
      24             : 
      25             : #if HAVE_IBASE
      26             : 
      27             : #include "php_interbase.h"
      28             : #include "php_ibase_includes.h"
      29             : 
      30             : typedef struct {
      31             :         isc_svc_handle handle;
      32             :         char *hostname;
      33             :         char *username;
      34             :         zend_resource *res;
      35             : } ibase_service;
      36             : 
      37             : static int le_service;
      38             : 
      39           0 : static void _php_ibase_free_service(zend_resource *rsrc) /* {{{ */
      40             : {
      41           0 :         ibase_service *sv = (ibase_service *) rsrc->ptr;
      42             : 
      43           0 :         if (isc_service_detach(IB_STATUS, &sv->handle)) {
      44           0 :                 _php_ibase_error();
      45             :         }
      46             : 
      47           0 :         if (sv->hostname) {
      48           0 :                 efree(sv->hostname);
      49             :         }
      50           0 :         if (sv->username) {
      51           0 :                 efree(sv->username);
      52             :         }
      53             : 
      54           0 :         efree(sv);
      55           0 : }
      56             : /* }}} */
      57             : 
      58             : /* the svc api seems to get confused after an error has occurred,
      59             :    so invalidate the handle on errors */
      60             : #define IBASE_SVC_ERROR(svm) \
      61             :         do { zend_list_delete(svm->res); _php_ibase_error(); } while (0)
      62             : 
      63             : 
      64       24416 : void php_ibase_service_minit(INIT_FUNC_ARGS) /* {{{ */
      65             : {
      66       24416 :         le_service = zend_register_list_destructors_ex(_php_ibase_free_service, NULL,
      67             :             "interbase service manager handle", module_number);
      68             : 
      69             :         /* backup options */
      70       24416 :         REGISTER_LONG_CONSTANT("IBASE_BKP_IGNORE_CHECKSUMS", isc_spb_bkp_ignore_checksums, CONST_PERSISTENT);
      71       24416 :         REGISTER_LONG_CONSTANT("IBASE_BKP_IGNORE_LIMBO", isc_spb_bkp_ignore_limbo, CONST_PERSISTENT);
      72       24416 :         REGISTER_LONG_CONSTANT("IBASE_BKP_METADATA_ONLY", isc_spb_bkp_metadata_only, CONST_PERSISTENT);
      73       24416 :         REGISTER_LONG_CONSTANT("IBASE_BKP_NO_GARBAGE_COLLECT", isc_spb_bkp_no_garbage_collect, CONST_PERSISTENT);
      74       24416 :         REGISTER_LONG_CONSTANT("IBASE_BKP_OLD_DESCRIPTIONS", isc_spb_bkp_old_descriptions, CONST_PERSISTENT);
      75       24416 :         REGISTER_LONG_CONSTANT("IBASE_BKP_NON_TRANSPORTABLE", isc_spb_bkp_non_transportable, CONST_PERSISTENT);
      76       24416 :         REGISTER_LONG_CONSTANT("IBASE_BKP_CONVERT", isc_spb_bkp_convert, CONST_PERSISTENT);
      77             : 
      78             :         /* restore options */
      79       24416 :         REGISTER_LONG_CONSTANT("IBASE_RES_DEACTIVATE_IDX", isc_spb_res_deactivate_idx, CONST_PERSISTENT);
      80       24416 :         REGISTER_LONG_CONSTANT("IBASE_RES_NO_SHADOW", isc_spb_res_no_shadow, CONST_PERSISTENT);
      81       24416 :         REGISTER_LONG_CONSTANT("IBASE_RES_NO_VALIDITY", isc_spb_res_no_validity, CONST_PERSISTENT);
      82       24416 :         REGISTER_LONG_CONSTANT("IBASE_RES_ONE_AT_A_TIME", isc_spb_res_one_at_a_time, CONST_PERSISTENT);
      83       24416 :         REGISTER_LONG_CONSTANT("IBASE_RES_REPLACE", isc_spb_res_replace, CONST_PERSISTENT);
      84       24416 :         REGISTER_LONG_CONSTANT("IBASE_RES_CREATE", isc_spb_res_create, CONST_PERSISTENT);
      85       24416 :         REGISTER_LONG_CONSTANT("IBASE_RES_USE_ALL_SPACE", isc_spb_res_use_all_space, CONST_PERSISTENT);
      86             : 
      87             :         /* manage options */
      88       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_PAGE_BUFFERS", isc_spb_prp_page_buffers, CONST_PERSISTENT);
      89       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_SWEEP_INTERVAL", isc_spb_prp_sweep_interval, CONST_PERSISTENT);
      90       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_SHUTDOWN_DB", isc_spb_prp_shutdown_db, CONST_PERSISTENT);
      91       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_DENY_NEW_TRANSACTIONS", isc_spb_prp_deny_new_transactions, CONST_PERSISTENT);
      92       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_DENY_NEW_ATTACHMENTS", isc_spb_prp_deny_new_attachments, CONST_PERSISTENT);
      93       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_RESERVE_SPACE", isc_spb_prp_reserve_space, CONST_PERSISTENT);
      94       24416 :           REGISTER_LONG_CONSTANT("IBASE_PRP_RES_USE_FULL", isc_spb_prp_res_use_full, CONST_PERSISTENT);
      95       24416 :           REGISTER_LONG_CONSTANT("IBASE_PRP_RES", isc_spb_prp_res, CONST_PERSISTENT);
      96       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_WRITE_MODE", isc_spb_prp_write_mode, CONST_PERSISTENT);
      97       24416 :           REGISTER_LONG_CONSTANT("IBASE_PRP_WM_ASYNC", isc_spb_prp_wm_async, CONST_PERSISTENT);
      98       24416 :           REGISTER_LONG_CONSTANT("IBASE_PRP_WM_SYNC", isc_spb_prp_wm_sync, CONST_PERSISTENT);
      99       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_ACCESS_MODE", isc_spb_prp_access_mode, CONST_PERSISTENT);
     100       24416 :           REGISTER_LONG_CONSTANT("IBASE_PRP_AM_READONLY", isc_spb_prp_am_readonly, CONST_PERSISTENT);
     101       24416 :           REGISTER_LONG_CONSTANT("IBASE_PRP_AM_READWRITE", isc_spb_prp_am_readwrite, CONST_PERSISTENT);
     102       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_SET_SQL_DIALECT", isc_spb_prp_set_sql_dialect, CONST_PERSISTENT);
     103       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_ACTIVATE", isc_spb_prp_activate, CONST_PERSISTENT);
     104       24416 :         REGISTER_LONG_CONSTANT("IBASE_PRP_DB_ONLINE", isc_spb_prp_db_online, CONST_PERSISTENT);
     105             : 
     106             :         /* repair options */
     107       24416 :         REGISTER_LONG_CONSTANT("IBASE_RPR_CHECK_DB", isc_spb_rpr_check_db, CONST_PERSISTENT);
     108       24416 :         REGISTER_LONG_CONSTANT("IBASE_RPR_IGNORE_CHECKSUM", isc_spb_rpr_ignore_checksum, CONST_PERSISTENT);
     109       24416 :         REGISTER_LONG_CONSTANT("IBASE_RPR_KILL_SHADOWS", isc_spb_rpr_kill_shadows, CONST_PERSISTENT);
     110       24416 :         REGISTER_LONG_CONSTANT("IBASE_RPR_MEND_DB", isc_spb_rpr_mend_db, CONST_PERSISTENT);
     111       24416 :         REGISTER_LONG_CONSTANT("IBASE_RPR_VALIDATE_DB", isc_spb_rpr_validate_db, CONST_PERSISTENT);
     112       24416 :           REGISTER_LONG_CONSTANT("IBASE_RPR_FULL", isc_spb_rpr_full, CONST_PERSISTENT);
     113       24416 :         REGISTER_LONG_CONSTANT("IBASE_RPR_SWEEP_DB", isc_spb_rpr_sweep_db, CONST_PERSISTENT);
     114             : 
     115             :         /* db info arguments */
     116       24416 :         REGISTER_LONG_CONSTANT("IBASE_STS_DATA_PAGES", isc_spb_sts_data_pages, CONST_PERSISTENT);
     117       24416 :         REGISTER_LONG_CONSTANT("IBASE_STS_DB_LOG", isc_spb_sts_db_log, CONST_PERSISTENT);
     118       24416 :         REGISTER_LONG_CONSTANT("IBASE_STS_HDR_PAGES", isc_spb_sts_hdr_pages, CONST_PERSISTENT);
     119       24416 :         REGISTER_LONG_CONSTANT("IBASE_STS_IDX_PAGES", isc_spb_sts_idx_pages, CONST_PERSISTENT);
     120       24416 :         REGISTER_LONG_CONSTANT("IBASE_STS_SYS_RELATIONS", isc_spb_sts_sys_relations, CONST_PERSISTENT);
     121             : 
     122             :         /* server info arguments */
     123       24416 :         REGISTER_LONG_CONSTANT("IBASE_SVC_SERVER_VERSION", isc_info_svc_server_version, CONST_PERSISTENT);
     124       24416 :         REGISTER_LONG_CONSTANT("IBASE_SVC_IMPLEMENTATION", isc_info_svc_implementation, CONST_PERSISTENT);
     125       24416 :         REGISTER_LONG_CONSTANT("IBASE_SVC_GET_ENV", isc_info_svc_get_env, CONST_PERSISTENT);
     126       24416 :         REGISTER_LONG_CONSTANT("IBASE_SVC_GET_ENV_LOCK", isc_info_svc_get_env_lock, CONST_PERSISTENT);
     127       24416 :         REGISTER_LONG_CONSTANT("IBASE_SVC_GET_ENV_MSG", isc_info_svc_get_env_msg, CONST_PERSISTENT);
     128       24416 :         REGISTER_LONG_CONSTANT("IBASE_SVC_USER_DBPATH", isc_info_svc_user_dbpath, CONST_PERSISTENT);
     129       24416 :         REGISTER_LONG_CONSTANT("IBASE_SVC_SVR_DB_INFO", isc_info_svc_svr_db_info, CONST_PERSISTENT);
     130       24416 :         REGISTER_LONG_CONSTANT("IBASE_SVC_GET_USERS", isc_info_svc_get_users, CONST_PERSISTENT);
     131       24416 : }
     132             : /* }}} */
     133             : 
     134           0 : static void _php_ibase_user(INTERNAL_FUNCTION_PARAMETERS, char operation) /* {{{ */
     135             : {
     136             :         /* user = 0, password = 1, first_name = 2, middle_name = 3, last_name = 4 */
     137             :         static char const user_flags[] = { isc_spb_sec_username, isc_spb_sec_password,
     138             :             isc_spb_sec_firstname, isc_spb_sec_middlename, isc_spb_sec_lastname };
     139           0 :         char buf[128], *args[] = { NULL, NULL, NULL, NULL, NULL };
     140           0 :         int i, args_len[] = { 0, 0, 0, 0, 0 };
     141           0 :         unsigned short spb_len = 1;
     142             :         zval *res;
     143             :         ibase_service *svm;
     144             : 
     145           0 :         RESET_ERRMSG;
     146             : 
     147           0 :         if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS(),
     148             :                         (operation == isc_action_svc_delete_user) ? "rs" : "rss|sss",
     149             :                         &res, &args[0], &args_len[0], &args[1], &args_len[1], &args[2], &args_len[2],
     150             :                         &args[3], &args_len[3], &args[4], &args_len[4])) {
     151           0 :                 RETURN_FALSE;
     152             :         }
     153             : 
     154           0 :         svm = (ibase_service *)zend_fetch_resource_ex(res, "Interbase service manager handle",
     155             :                 le_service);
     156             : 
     157           0 :         buf[0] = operation;
     158             : 
     159           0 :         for (i = 0; i < sizeof(user_flags); ++i) {
     160           0 :                 if (args[i] != NULL) {
     161           0 :                         int chunk = slprintf(&buf[spb_len], sizeof(buf) - spb_len, "%c%c%c%s",
     162           0 :                                 user_flags[i], (char)args_len[i], (char)(args_len[i] >> 8), args[i]);
     163             : 
     164           0 :                         if ((spb_len + chunk) > sizeof(buf) || chunk <= 0) {
     165           0 :                                 _php_ibase_module_error("Internal error: insufficient buffer space for SPB (%d)", spb_len);
     166           0 :                                 RETURN_FALSE;
     167             :                         }
     168           0 :                         spb_len += chunk;
     169             :                 }
     170             :         }
     171             : 
     172             :         /* now start the job */
     173           0 :         if (isc_service_start(IB_STATUS, &svm->handle, NULL, spb_len, buf)) {
     174           0 :                 IBASE_SVC_ERROR(svm);
     175           0 :                 RETURN_FALSE;
     176             :         }
     177             : 
     178           0 :         RETURN_TRUE;
     179             : }
     180             : /* }}} */
     181             : 
     182             : /* {{{ proto bool ibase_add_user(resource service_handle, string user_name, string password [, string first_name [, string middle_name [, string last_name]]])
     183             :    Add a user to security database */
     184           0 : PHP_FUNCTION(ibase_add_user)
     185             : {
     186           0 :         _php_ibase_user(INTERNAL_FUNCTION_PARAM_PASSTHRU, isc_action_svc_add_user);
     187           0 : }
     188             : /* }}} */
     189             : 
     190             : /* {{{ proto bool ibase_modify_user(resource service_handle, string user_name, string password [, string first_name [, string middle_name [, string last_name]]])
     191             :    Modify a user in security database */
     192           0 : PHP_FUNCTION(ibase_modify_user)
     193             : {
     194           0 :         _php_ibase_user(INTERNAL_FUNCTION_PARAM_PASSTHRU, isc_action_svc_modify_user);
     195           0 : }
     196             : /* }}} */
     197             : 
     198             : /* {{{ proto bool ibase_delete_user(resource service_handle, string user_name, string password [, string first_name [, string middle_name [, string last_name]]])
     199             :    Delete a user from security database */
     200           0 : PHP_FUNCTION(ibase_delete_user)
     201             : {
     202           0 :         _php_ibase_user(INTERNAL_FUNCTION_PARAM_PASSTHRU, isc_action_svc_delete_user);
     203           0 : }
     204             : /* }}} */
     205             : 
     206             : /* {{{ proto resource ibase_service_attach(string host, string dba_username, string dba_password)
     207             :    Connect to the service manager */
     208           0 : PHP_FUNCTION(ibase_service_attach)
     209             : {
     210             :         size_t hlen, ulen, plen, spb_len;
     211             :         ibase_service *svm;
     212             :         char buf[128], *host, *user, *pass, *loc;
     213           0 :         isc_svc_handle handle = 0;
     214             : 
     215           0 :         RESET_ERRMSG;
     216             : 
     217           0 :         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "sss",
     218             :                         &host, &hlen, &user, &ulen, &pass, &plen)) {
     219             : 
     220           0 :                 RETURN_FALSE;
     221             :         }
     222             : 
     223             :         /* construct the spb, hack the service name into it as well */
     224           0 :         spb_len = slprintf(buf, sizeof(buf), "%c%c%c%c%s%c%c%s" "%s:service_mgr",
     225           0 :                 isc_spb_version, isc_spb_current_version, isc_spb_user_name, (char)ulen,
     226           0 :                 user, isc_spb_password, (char)plen, pass, host);
     227             : 
     228           0 :         if (spb_len > sizeof(buf) || spb_len == -1) {
     229           0 :                 _php_ibase_module_error("Internal error: insufficient buffer space for SPB (%zd)", spb_len);
     230           0 :                 RETURN_FALSE;
     231             :         }
     232             : 
     233           0 :         spb_len -= hlen + 12;
     234           0 :         loc = buf + spb_len; /* points to %s:service_mgr part */
     235             : 
     236             :         /* attach to the service manager */
     237           0 :         if (isc_service_attach(IB_STATUS, 0, loc, &handle, (unsigned short)spb_len, buf)) {
     238           0 :                 _php_ibase_error();
     239           0 :                 RETURN_FALSE;
     240             :         }
     241             : 
     242           0 :         svm = (ibase_service*)emalloc(sizeof(ibase_service));
     243           0 :         svm->handle = handle;
     244           0 :         svm->hostname = estrdup(host);
     245           0 :         svm->username = estrdup(user);
     246             : 
     247           0 :         RETVAL_RES(zend_register_resource(svm, le_service));
     248           0 :         Z_TRY_ADDREF_P(return_value);
     249           0 :         svm->res = Z_RES_P(return_value);
     250             : }
     251             : /* }}} */
     252             : 
     253             : /* {{{ proto bool ibase_service_detach(resource service_handle)
     254             :    Disconnect from the service manager */
     255           0 : PHP_FUNCTION(ibase_service_detach)
     256             : {
     257             :         zval *res;
     258             : 
     259           0 :         RESET_ERRMSG;
     260             : 
     261           0 :         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "r", &res)) {
     262           0 :                 RETURN_FALSE;
     263             :         }
     264             : 
     265           0 :         zend_list_delete(Z_RES_P(res));
     266             : 
     267           0 :         RETURN_TRUE;
     268             : }
     269             : /* }}} */
     270             : 
     271           0 : static void _php_ibase_service_query(INTERNAL_FUNCTION_PARAMETERS, /* {{{ */
     272             :         ibase_service *svm, char info_action)
     273             : {
     274             :         static char spb[] = { isc_info_svc_timeout, 10, 0, 0, 0 };
     275             : 
     276           0 :         char res_buf[400], *result, *heap_buf = NULL, *heap_p;
     277           0 :         zend_long heap_buf_size = 200, line_len;
     278             : 
     279             :         /* info about users requires an action first */
     280           0 :         if (info_action == isc_info_svc_get_users) {
     281             :                 static char action[] = { isc_action_svc_display_user };
     282             : 
     283           0 :                 if (isc_service_start(IB_STATUS, &svm->handle, NULL, sizeof(action), action)) {
     284           0 :                         IBASE_SVC_ERROR(svm);
     285           0 :                         RETURN_FALSE;
     286             :                 }
     287             :         }
     288             : 
     289             : query_loop:
     290           0 :         result = res_buf;
     291             : 
     292           0 :         if (isc_service_query(IB_STATUS, &svm->handle, NULL, sizeof(spb), spb,
     293             :                         1, &info_action, sizeof(res_buf), res_buf)) {
     294             : 
     295           0 :                 IBASE_SVC_ERROR(svm);
     296           0 :                 RETURN_FALSE;
     297             :         }
     298           0 :         while (*result != isc_info_end) {
     299           0 :                 switch (*result++) {
     300             :                         default:
     301           0 :                                 RETURN_FALSE;
     302             : 
     303             :                         case isc_info_svc_line:
     304           0 :                                 if (! (line_len = isc_vax_integer(result, 2))) {
     305             :                                         /* done */
     306           0 :                                         if (heap_buf) {
     307           0 :                                                 RETVAL_STRING(heap_buf);
     308           0 :                                                 efree(heap_buf);
     309           0 :                                                 return;
     310             :                                         } else {
     311           0 :                                                 RETURN_TRUE;
     312             :                                         }
     313             :                                 }
     314           0 :                                 if (!heap_buf || (heap_p - heap_buf + line_len +2) > heap_buf_size) {
     315           0 :                                         zend_long res_size = heap_buf ? heap_p - heap_buf : 0;
     316             : 
     317           0 :                                         while (heap_buf_size < (res_size + line_len +2)) {
     318           0 :                                                 heap_buf_size *= 2;
     319             :                                         }
     320           0 :                                         heap_buf = (char*) erealloc(heap_buf, heap_buf_size);
     321           0 :                                         heap_p = heap_buf + res_size;
     322             :                                 }
     323           0 :                                 result += 2;
     324           0 :                                 *(result+line_len) = 0;
     325           0 :                                 snprintf(heap_p, heap_buf_size - (heap_p - heap_buf), "%s\n", result);
     326           0 :                                 heap_p += line_len +1;
     327           0 :                                 goto query_loop; /* repeat until result is exhausted */
     328             : 
     329             :                         case isc_info_svc_server_version:
     330             :                         case isc_info_svc_implementation:
     331             :                         case isc_info_svc_get_env:
     332             :                         case isc_info_svc_get_env_lock:
     333             :                         case isc_info_svc_get_env_msg:
     334             :                         case isc_info_svc_user_dbpath:
     335           0 :                                 RETURN_STRINGL(result + 2, isc_vax_integer(result, 2));
     336             : 
     337             :                         case isc_info_svc_svr_db_info:
     338           0 :                                 array_init(return_value);
     339             : 
     340             :                                 do {
     341           0 :                                         switch (*result++) {
     342             :                                                 int len;
     343             : 
     344             :                                                 case isc_spb_num_att:
     345           0 :                                                         add_assoc_long(return_value, "attachments", isc_vax_integer(result,4));
     346           0 :                                                         result += 4;
     347           0 :                                                         break;
     348             : 
     349             :                                                 case isc_spb_num_db:
     350           0 :                                                         add_assoc_long(return_value, "databases", isc_vax_integer(result,4));
     351           0 :                                                         result += 4;
     352           0 :                                                         break;
     353             : 
     354             :                                                 case isc_spb_dbname:
     355           0 :                                                         len = isc_vax_integer(result,2);
     356           0 :                                                         add_next_index_stringl(return_value, result +2, len);
     357           0 :                                                         result += len+2;
     358             :                                         }
     359           0 :                                 } while (*result != isc_info_flag_end);
     360           0 :                                 return;
     361             : 
     362             :                         case isc_info_svc_get_users: {
     363             :                                 zval user;
     364           0 :                                 array_init(return_value);
     365             : 
     366           0 :                                 while (*result != isc_info_end) {
     367             : 
     368           0 :                                         switch (*result++) {
     369             :                                                 int len;
     370             : 
     371             :                                                 case isc_spb_sec_username:
     372             :                                                         /* it appears that the username is always first */
     373           0 :                                                         array_init(&user);
     374           0 :                                                         add_next_index_zval(return_value, &user);
     375             : 
     376           0 :                                                         len = isc_vax_integer(result,2);
     377           0 :                                                         add_assoc_stringl(&user, "user_name", result +2, len);
     378           0 :                                                         result += len+2;
     379           0 :                                                         break;
     380             : 
     381             :                                                 case isc_spb_sec_firstname:
     382           0 :                                                         len = isc_vax_integer(result,2);
     383           0 :                                                         add_assoc_stringl(&user, "first_name", result +2, len);
     384           0 :                                                         result += len+2;
     385           0 :                                                         break;
     386             : 
     387             :                                                 case isc_spb_sec_middlename:
     388           0 :                                                         len = isc_vax_integer(result,2);
     389           0 :                                                         add_assoc_stringl(&user, "middle_name", result +2, len);
     390           0 :                                                         result += len+2;
     391           0 :                                                         break;
     392             : 
     393             :                                                 case isc_spb_sec_lastname:
     394           0 :                                                         len = isc_vax_integer(result,2);
     395           0 :                                                         add_assoc_stringl(&user, "last_name", result +2, len);
     396           0 :                                                         result += len+2;
     397           0 :                                                         break;
     398             : 
     399             :                                                 case isc_spb_sec_userid:
     400           0 :                                                         add_assoc_long(&user, "user_id", isc_vax_integer(result, 4));
     401           0 :                                                         result += 4;
     402           0 :                                                         break;
     403             : 
     404             :                                                 case isc_spb_sec_groupid:
     405           0 :                                                         add_assoc_long(&user, "group_id", isc_vax_integer(result, 4));
     406           0 :                                                         result += 4;
     407             :                                                         break;
     408             :                                         }
     409             :                                 }
     410           0 :                                 return;
     411             :                         }
     412             :                 }
     413             :         }
     414             : }
     415             : /* }}} */
     416             : 
     417           0 : static void _php_ibase_backup_restore(INTERNAL_FUNCTION_PARAMETERS, char operation) /* {{{ */
     418             : {
     419             :         /**
     420             :          * It appears that the service API is a little bit confused about which flag
     421             :          * to use for the source and destination in the case of a restore operation.
     422             :          * When passing the backup file as isc_spb_dbname and the destination db as
     423             :          * bpk_file, things work well.
     424             :          */
     425             :         zval *res;
     426             :         char *db, *bk, buf[200];
     427             :         size_t dblen, bklen, spb_len;
     428           0 :         zend_long opts = 0;
     429           0 :         zend_bool verbose = 0;
     430             :         ibase_service *svm;
     431             : 
     432           0 :         RESET_ERRMSG;
     433             : 
     434           0 :         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "rss|lb",
     435             :                         &res, &db, &dblen, &bk, &bklen, &opts, &verbose)) {
     436           0 :                 RETURN_FALSE;
     437             :         }
     438             : 
     439           0 :         svm = (ibase_service *)zend_fetch_resource_ex(res,
     440             :                 "Interbase service manager handle", le_service);
     441             : 
     442             :         /* fill the param buffer */
     443           0 :         spb_len = slprintf(buf, sizeof(buf), "%c%c%c%c%s%c%c%c%s%c%c%c%c%c",
     444           0 :                 operation, isc_spb_dbname, (char)dblen, (char)(dblen >> 8), db,
     445           0 :                 isc_spb_bkp_file, (char)bklen, (char)(bklen >> 8), bk, isc_spb_options,
     446           0 :                 (char)opts,(char)(opts >> 8), (char)(opts >> 16), (char)(opts >> 24));
     447             : 
     448           0 :         if (verbose) {
     449           0 :                 buf[spb_len++] = isc_spb_verbose;
     450             :         }
     451             : 
     452           0 :         if (spb_len > sizeof(buf) || spb_len <= 0) {
     453           0 :                 _php_ibase_module_error("Internal error: insufficient buffer space for SPB (%zd)", spb_len);
     454           0 :                 RETURN_FALSE;
     455             :         }
     456             : 
     457             :         /* now start the backup/restore job */
     458           0 :         if (isc_service_start(IB_STATUS, &svm->handle, NULL, (unsigned short)spb_len, buf)) {
     459           0 :                 IBASE_SVC_ERROR(svm);
     460           0 :                 RETURN_FALSE;
     461             :         }
     462             : 
     463           0 :         if (!verbose) {
     464           0 :                 RETURN_TRUE;
     465             :         } else {
     466           0 :                 _php_ibase_service_query(INTERNAL_FUNCTION_PARAM_PASSTHRU, svm, isc_info_svc_line);
     467             :         }
     468             : }
     469             : /* }}} */
     470             : 
     471             : /* {{{ proto mixed ibase_backup(resource service_handle, string source_db, string dest_file [, int options [, bool verbose]])
     472             :    Initiates a backup task in the service manager and returns immediately */
     473           0 : PHP_FUNCTION(ibase_backup)
     474             : {
     475           0 :         _php_ibase_backup_restore(INTERNAL_FUNCTION_PARAM_PASSTHRU, isc_action_svc_backup);
     476           0 : }
     477             : /* }}} */
     478             : 
     479             : /* {{{ proto mixed ibase_restore(resource service_handle, string source_file, string dest_db [, int options [, bool verbose]])
     480             :    Initiates a restore task in the service manager and returns immediately */
     481           0 : PHP_FUNCTION(ibase_restore)
     482             : {
     483           0 :         _php_ibase_backup_restore(INTERNAL_FUNCTION_PARAM_PASSTHRU, isc_action_svc_restore);
     484           0 : }
     485             : /* }}} */
     486             : 
     487           0 : static void _php_ibase_service_action(INTERNAL_FUNCTION_PARAMETERS, char svc_action) /* {{{ */
     488             : {
     489             :         zval *res;
     490             :         char buf[128], *db;
     491             :         size_t dblen;
     492             :         int spb_len;
     493           0 :         zend_long action, argument = 0;
     494             :         ibase_service *svm;
     495             : 
     496           0 :         RESET_ERRMSG;
     497             : 
     498           0 :         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "rsl|l",
     499             :                         &res, &db, &dblen, &action, &argument)) {
     500           0 :                 RETURN_FALSE;
     501             :         }
     502             : 
     503           0 :         svm = (ibase_service *)zend_fetch_resource_ex(res,
     504             :                 "Interbase service manager handle", le_service);
     505             : 
     506           0 :         if (svc_action == isc_action_svc_db_stats) {
     507           0 :                 switch (action) {
     508             :                         default:
     509           0 :                                 goto unknown_option;
     510             : 
     511             :                         case isc_spb_sts_data_pages:
     512             :                         case isc_spb_sts_db_log:
     513             :                         case isc_spb_sts_hdr_pages:
     514             :                         case isc_spb_sts_idx_pages:
     515             :                         case isc_spb_sts_sys_relations:
     516           0 :                                 goto options_argument;
     517             :                 }
     518             :         } else {
     519             :                 /* these actions all expect different types of arguments */
     520           0 :                 switch (action) {
     521             :                         default:
     522             : unknown_option:
     523           0 :                                 _php_ibase_module_error("Unrecognised option (" ZEND_LONG_FMT ")", action);
     524           0 :                                 RETURN_FALSE;
     525             : 
     526             :                         case isc_spb_rpr_check_db:
     527             :                         case isc_spb_rpr_ignore_checksum:
     528             :                         case isc_spb_rpr_kill_shadows:
     529             :                         case isc_spb_rpr_mend_db:
     530             :                         case isc_spb_rpr_validate_db:
     531             :                         case isc_spb_rpr_sweep_db:
     532           0 :                                 svc_action = isc_action_svc_repair;
     533             : 
     534             :                         case isc_spb_prp_activate:
     535             :                         case isc_spb_prp_db_online:
     536             : options_argument:
     537           0 :                                 argument |= action;
     538           0 :                                 action = isc_spb_options;
     539             : 
     540             :                         case isc_spb_prp_page_buffers:
     541             :                         case isc_spb_prp_sweep_interval:
     542             :                         case isc_spb_prp_shutdown_db:
     543             :                         case isc_spb_prp_deny_new_transactions:
     544             :                         case isc_spb_prp_deny_new_attachments:
     545             :                         case isc_spb_prp_set_sql_dialect:
     546           0 :                                 spb_len = slprintf(buf, sizeof(buf), "%c%c%c%c%s%c%c%c%c%c",
     547           0 :                                         svc_action, isc_spb_dbname, (char)dblen, (char)(dblen >> 8), db,
     548           0 :                                         (char)action, (char)argument, (char)(argument >> 8), (char)(argument >> 16),
     549           0 :                                         (char)(argument >> 24));
     550           0 :                                 break;
     551             : 
     552             :                         case isc_spb_prp_reserve_space:
     553             :                         case isc_spb_prp_write_mode:
     554             :                         case isc_spb_prp_access_mode:
     555           0 :                                 spb_len = slprintf(buf, sizeof(buf), "%c%c%c%c%s%c%c",
     556           0 :                                         isc_action_svc_properties, isc_spb_dbname, (char)dblen, (char)(dblen >> 8),
     557           0 :                                         db, (char)action, (char)argument);
     558             :                 }
     559             :         }
     560             : 
     561           0 :         if (spb_len > sizeof(buf) || spb_len == -1) {
     562           0 :                 _php_ibase_module_error("Internal error: insufficient buffer space for SPB (%d)", spb_len);
     563           0 :                 RETURN_FALSE;
     564             :         }
     565             : 
     566           0 :         if (isc_service_start(IB_STATUS, &svm->handle, NULL, (unsigned short)spb_len, buf)) {
     567           0 :                 IBASE_SVC_ERROR(svm);
     568           0 :                 RETURN_FALSE;
     569             :         }
     570             : 
     571           0 :         if (svc_action == isc_action_svc_db_stats) {
     572           0 :                 _php_ibase_service_query(INTERNAL_FUNCTION_PARAM_PASSTHRU, svm, isc_info_svc_line);
     573             :         } else {
     574           0 :                 RETURN_TRUE;
     575             :         }
     576             : }
     577             : /* }}} */
     578             : 
     579             : /* {{{ proto bool ibase_maintain_db(resource service_handle, string db, int action [, int argument])
     580             :    Execute a maintenance command on the database server */
     581           0 : PHP_FUNCTION(ibase_maintain_db)
     582             : {
     583           0 :         _php_ibase_service_action(INTERNAL_FUNCTION_PARAM_PASSTHRU, isc_action_svc_properties);
     584           0 : }
     585             : /* }}} */
     586             : 
     587             : /* {{{ proto string ibase_db_info(resource service_handle, string db, int action [, int argument])
     588             :    Request statistics about a database */
     589           0 : PHP_FUNCTION(ibase_db_info)
     590             : {
     591           0 :         _php_ibase_service_action(INTERNAL_FUNCTION_PARAM_PASSTHRU, isc_action_svc_db_stats);
     592           0 : }
     593             : /* }}} */
     594             : 
     595             : /* {{{ proto string ibase_server_info(resource service_handle, int action)
     596             :    Request information about a database server */
     597           0 : PHP_FUNCTION(ibase_server_info)
     598             : {
     599             :         zval *res;
     600             :         zend_long action;
     601             :         ibase_service *svm;
     602             : 
     603           0 :         RESET_ERRMSG;
     604             : 
     605           0 :         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "rl", &res, &action)) {
     606           0 :                 RETURN_FALSE;
     607             :         }
     608             : 
     609           0 :         svm = (ibase_service *)zend_fetch_resource_ex(res,
     610             :                 "Interbase service manager handle", le_service);
     611             : 
     612           0 :         _php_ibase_service_query(INTERNAL_FUNCTION_PARAM_PASSTHRU, svm, (char)action);
     613             : }
     614             : /* }}} */
     615             : 
     616             : #else
     617             : 
     618             : void php_ibase_register_service_constants(INIT_FUNC_ARGS) { /* nop */ }
     619             : 
     620             : #endif /* HAVE_IBASE */
     621             : 
     622             : /*
     623             :  * Local variables:
     624             :  * tab-width: 4
     625             :  * c-basic-offset: 4
     626             :  * End:
     627             :  * vim600: sw=4 ts=4 fdm=marker
     628             :  * vim<600: sw=4 ts=4
     629             :  */

Generated by: LCOV version 1.10

Generated at Fri, 21 Jul 2017 05:20:42 +0000 (5 days ago)

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