merged Linux to CPP files

source/sqlsrv/conn.cpp

@@ -18,9 +18,12 @@
 //---------------------------------------------------------------------------------------------------------------------------------
 
 #include "php_sqlsrv.h"
+
+#ifndef __linux__
 #include <psapi.h>
 #include <windows.h>
 #include <winver.h>
+#endif
 
 #include <string>
 #include <sstream>
@@ -146,12 +149,12 @@ int get_stmt_option_key( zend_string* key, size_t key_len TSRMLS_DC );
 
 // constants for parameters used by process_params function(s)
 int ss_sqlsrv_conn::descriptor;
-char* ss_sqlsrv_conn::resource_name = "ss_sqlsrv_conn";
+char* ss_sqlsrv_conn::resource_name = static_cast<char *>("ss_sqlsrv_conn");
 
 // connection specific parameter proccessing.  Use the generic function specialised to return a connection
 // resource.
 #define PROCESS_PARAMS( rsrc, param_spec, calling_func, param_count, ... )                                                          \
-    rsrc = process_params<ss_sqlsrv_conn>( INTERNAL_FUNCTION_PARAM_PASSTHRU, param_spec, calling_func, param_count, __VA_ARGS__ );  \
+    rsrc = process_params<ss_sqlsrv_conn>( INTERNAL_FUNCTION_PARAM_PASSTHRU, param_spec, calling_func, param_count, ##__VA_ARGS__ );\
     if( rsrc == NULL ) {                                                                                                            \
         RETURN_FALSE;                                                                                                               \
     }
@@ -765,7 +768,10 @@ PHP_FUNCTION( sqlsrv_client_info )
         core_sqlsrv_get_client_info( conn, return_value TSRMLS_CC );
         
         // Add the sqlsrv driver's file version
-        core::sqlsrv_add_assoc_string( *conn, return_value, "ExtensionVer", VER_FILEVERSION_STR, 1 /*duplicate*/ TSRMLS_CC );
+        //Declarations below eliminate compiler warnings about string constant to char* conversions
+        const char* extver = "ExtensionVer";
+        std::string filever = VER_FILEVERSION_STR;
+        core::sqlsrv_add_assoc_string( *conn, return_value, extver, &filever[0], 1 /*duplicate*/ TSRMLS_CC );
     }
 
     catch( core::CoreException& ) {
@@ -978,7 +984,7 @@ PHP_FUNCTION( sqlsrv_query )
     sqlsrv_malloc_auto_ptr<ss_sqlsrv_stmt> stmt;
     char* sql = NULL;
     hash_auto_ptr ss_stmt_options_ht;
-    int sql_len = 0;
+    size_t sql_len = 0;
     zval* options_z = NULL;
     zval* params_z = NULL;	
     zval stmt_z;
@@ -1026,7 +1032,7 @@ PHP_FUNCTION( sqlsrv_query )
         bind_params( stmt TSRMLS_CC );
 
         // execute the statement
-        core_sqlsrv_execute( stmt TSRMLS_CC, sql, sql_len );
+        core_sqlsrv_execute( stmt TSRMLS_CC, sql, static_cast<int>( sql_len ) );
        
         // register the statement with the PHP runtime 
         ss::zend_register_resource(stmt_z, stmt, ss_sqlsrv_stmt::descriptor, ss_sqlsrv_stmt::resource_name TSRMLS_CC);
@@ -1112,14 +1118,12 @@ void sqlsrv_conn_close_stmts( ss_sqlsrv_conn* conn TSRMLS_DC )
 		// delete the statement by deleting it from Zend's resource list, which will force its destruction
 		stmt->conn = NULL;
 
-		try {
+        // this would call the destructor on the statement.
-			// this would call the destructor on the statement.
+        // There's nothing we can do if the removal fails, so we just log it and move on.
-			int zr = zend_list_close(Z_RES_P(rsrc_ptr));
+        if( zend_list_close( Z_RES_P(rsrc_ptr) ) == FAILURE ) {
-		}
+            LOG(SEV_ERROR, "Failed to remove statement resource %1!d! when closing the connection", Z_RES_HANDLE_P(rsrc_ptr));
-		catch( core::CoreException& ) {
+        }
-			LOG(SEV_ERROR, "Failed to remove statement resource %1!d! when closing the connection", Z_RES_HANDLE_P(rsrc_ptr));
+    } ZEND_HASH_FOREACH_END();
-		}
-	} ZEND_HASH_FOREACH_END();
 
     zend_hash_destroy( conn->stmts );
     FREE_HASHTABLE( conn->stmts );
@@ -1230,8 +1234,6 @@ void validate_stmt_options( sqlsrv_context& ctx, zval* stmt_options, _Inout_ Has
 			ZEND_HASH_FOREACH_KEY_VAL( options_ht, int_key, key, data ) {
 				int type = HASH_KEY_NON_EXISTENT;
 				size_t key_len = 0;
-				zval* conn_opt = NULL;
-				int result = 0;
 
 				type = key ? HASH_KEY_IS_STRING : HASH_KEY_IS_LONG;
 

source/sqlsrv/init.cpp

@@ -328,8 +328,11 @@ PHP_MINIT_FUNCTION(sqlsrv)
     REGISTER_LONG_CONSTANT( "SQLSRV_PHPTYPE_FLOAT",    SQLSRV_PHPTYPE_FLOAT, CONST_PERSISTENT | CONST_CS );
     REGISTER_LONG_CONSTANT( "SQLSRV_PHPTYPE_DATETIME", SQLSRV_PHPTYPE_DATETIME, CONST_PERSISTENT | CONST_CS );
 
-    REGISTER_STRING_CONSTANT( "SQLSRV_ENC_BINARY", "binary", CONST_PERSISTENT | CONST_CS );
+    std::string bin = "binary";
-    REGISTER_STRING_CONSTANT( "SQLSRV_ENC_CHAR",   "char", CONST_PERSISTENT | CONST_CS );
+    std::string chr = "char";
+
+    REGISTER_STRING_CONSTANT( "SQLSRV_ENC_BINARY", &bin[0], CONST_PERSISTENT | CONST_CS );
+    REGISTER_STRING_CONSTANT( "SQLSRV_ENC_CHAR",   &chr[0], CONST_PERSISTENT | CONST_CS );
     
     REGISTER_LONG_CONSTANT( "SQLSRV_NULLABLE_NO",      0, CONST_PERSISTENT | CONST_CS );
     REGISTER_LONG_CONSTANT( "SQLSRV_NULLABLE_YES",     1, CONST_PERSISTENT | CONST_CS );
@@ -413,11 +416,17 @@ PHP_MINIT_FUNCTION(sqlsrv)
     REGISTER_LONG_CONSTANT( "SQLSRV_SCROLL_ABSOLUTE", SQL_FETCH_ABSOLUTE, CONST_PERSISTENT | CONST_CS );
     REGISTER_LONG_CONSTANT( "SQLSRV_SCROLL_RELATIVE", SQL_FETCH_RELATIVE, CONST_PERSISTENT | CONST_CS );
 
-    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_FORWARD", "forward", CONST_PERSISTENT | CONST_CS );
+    std::string fwd = "forward";
-    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_STATIC",  "static", CONST_PERSISTENT | CONST_CS );
+    std::string stc = "static";
-    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_DYNAMIC", "dynamic", CONST_PERSISTENT | CONST_CS );
+    std::string dyn = "dynamic";
-    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_KEYSET",  "keyset", CONST_PERSISTENT | CONST_CS );
+    std::string key = "keyset";
-    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_CLIENT_BUFFERED",  "buffered", CONST_PERSISTENT | CONST_CS );
+    std::string buf = "buffered";
+
+    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_FORWARD",         &fwd[0], CONST_PERSISTENT | CONST_CS );
+    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_STATIC",          &stc[0], CONST_PERSISTENT | CONST_CS );
+    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_DYNAMIC",         &dyn[0], CONST_PERSISTENT | CONST_CS );
+    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_KEYSET",          &key[0], CONST_PERSISTENT | CONST_CS );
+    REGISTER_STRING_CONSTANT( "SQLSRV_CURSOR_CLIENT_BUFFERED", &buf[0], CONST_PERSISTENT | CONST_CS );
 
     try {
 

source/sqlsrv/stmt.cpp

@@ -19,14 +19,16 @@
 
 // *** header files ***
 #include "php_sqlsrv.h"
+#ifndef __linux__
 #include <sal.h>
+#endif
 
 //
 // *** internal variables and constants ***
 //
 // our resource descriptor assigned in minit
 int ss_sqlsrv_stmt::descriptor = 0;
-char* ss_sqlsrv_stmt::resource_name = "ss_sqlsrv_stmt";   // not const for a reason.  see sqlsrv_stmt in php_sqlsrv.h
+char* ss_sqlsrv_stmt::resource_name = static_cast<char *>("ss_sqlsrv_stmt");   // not const for a reason.  see sqlsrv_stmt in php_sqlsrv.h
 
 namespace {
 
@@ -72,12 +74,12 @@ enum SQLSRV_PHPTYPE zend_to_sqlsrv_phptype[] = {
 // (char to avoid having to cast them where they are used)
 namespace FieldMetaData {
 
-char* NAME = "Name";
+const char* NAME = "Name";
-char* TYPE = "Type";
+const char* TYPE = "Type";
-char* SIZE = "Size";
+const char* SIZE = "Size";
-char* PREC = "Precision";
+const char* PREC = "Precision";
-char* SCALE = "Scale";
+const char* SCALE = "Scale";
-char* NULLABLE = "Nullable";
+const char* NULLABLE = "Nullable";
 
 }
 
@@ -248,7 +250,7 @@ sqlsrv_phptype ss_sqlsrv_stmt::sql_type_to_php_type( SQLINTEGER sql_type, SQLUIN
 // statement specific parameter proccessing.  Uses the generic function specialised to return a statement
 // resource.
 #define PROCESS_PARAMS( rsrc, param_spec, calling_func, param_count, ... )                                                        \
-    rsrc = process_params<ss_sqlsrv_stmt>( INTERNAL_FUNCTION_PARAM_PASSTHRU, param_spec, calling_func, param_count, __VA_ARGS__ );\
+    rsrc = process_params<ss_sqlsrv_stmt>( INTERNAL_FUNCTION_PARAM_PASSTHRU, param_spec, calling_func, param_count, ## __VA_ARGS__ );\
     if( rsrc == NULL ) {                                                                                                          \
         RETURN_FALSE;                                                                                                             \
     }
@@ -553,7 +555,6 @@ PHP_FUNCTION( sqlsrv_next_result )
 {
     LOG_FUNCTION( "sqlsrv_next_result" );
 
-    SQLRETURN r = SQL_SUCCESS;
     ss_sqlsrv_stmt* stmt = NULL;
 
     PROCESS_PARAMS( stmt, "r", _FN_, 0 );
@@ -597,7 +598,6 @@ PHP_FUNCTION( sqlsrv_next_result )
 PHP_FUNCTION( sqlsrv_rows_affected )
 {
     LOG_FUNCTION( "sqlsrv_rows_affected" );
-    SQLRETURN r = SQL_SUCCESS;
     ss_sqlsrv_stmt* stmt = NULL;
     SQLLEN rows = -1;
 
@@ -1067,7 +1067,7 @@ PHP_FUNCTION( sqlsrv_get_field )
     sqlsrv_php_type.typeinfo.type = SQLSRV_PHPTYPE_INVALID;
     SQLSRV_PHPTYPE sqlsrv_php_type_out = SQLSRV_PHPTYPE_INVALID;
     void* field_value = NULL;
-    int field_index = -1;
+    zend_long field_index = -1;
     SQLLEN field_len = -1;
 	zval retval_z;
 	ZVAL_UNDEF(&retval_z);
@@ -1084,8 +1084,8 @@ PHP_FUNCTION( sqlsrv_get_field )
             THROW_SS_ERROR( stmt, SS_SQLSRV_ERROR_INVALID_FUNCTION_PARAMETER, _FN_ );
         }
 
-		core_sqlsrv_get_field( stmt, field_index, sqlsrv_php_type, false, field_value, &field_len, false/*cache_field*/,
+        core_sqlsrv_get_field( stmt, static_cast<SQLUSMALLINT>( field_index ), sqlsrv_php_type, false, field_value, &field_len, false/*cache_field*/,
-			&sqlsrv_php_type_out TSRMLS_CC );
+            &sqlsrv_php_type_out TSRMLS_CC );
         convert_to_zval( stmt, sqlsrv_php_type_out, field_value, field_len, retval_z );		
 		sqlsrv_free( field_value );
         RETURN_ZVAL( &retval_z, 1, 1 );
@@ -1821,11 +1821,19 @@ void fetch_fields_common( _Inout_ ss_sqlsrv_stmt* stmt, zend_long fetch_type, _O
         sqlsrv_malloc_auto_ptr<char> field_name;
         sqlsrv_malloc_auto_ptr<sqlsrv_fetch_field_name> field_names;
         field_names = static_cast<sqlsrv_fetch_field_name*>( sqlsrv_malloc( num_cols * sizeof( sqlsrv_fetch_field_name )));
-        SQLSRV_ENCODING encoding = (( stmt->encoding() == SQLSRV_ENCODING_DEFAULT ) ? stmt->conn->encoding() : stmt->encoding());
+        SQLSRV_ENCODING encoding = (( stmt->encoding() == SQLSRV_ENCODING_DEFAULT ) ? stmt->conn->encoding() :
+            stmt->encoding());
         for( int i = 0; i < num_cols; ++i ) {
 
-            core::SQLColAttributeW( stmt, i + 1, SQL_DESC_NAME, field_name_w, ( SS_MAXCOLNAMELEN + 1 ) * 2, &field_name_len_w, NULL TSRMLS_CC );
+            core::SQLColAttributeW ( stmt, i + 1, SQL_DESC_NAME, field_name_w, ( SS_MAXCOLNAMELEN + 1 ) * 2, &field_name_len_w, NULL
-            bool converted = convert_string_from_utf16( encoding, field_name_w, field_name_len_w, ( char** ) &field_name, field_name_len );
+                                   TSRMLS_CC );
+    #ifdef __linux__
+            //Conversion function in Linux expects size in characters.
+            field_name_len_w = field_name_len_w / sizeof ( SQLWCHAR );
+    #endif
+            bool converted = convert_string_from_utf16( encoding, field_name_w,
+                field_name_len_w, ( char** ) &field_name, field_name_len );
+
             CHECK_CUSTOM_ERROR( !converted, stmt, SQLSRV_ERROR_FIELD_ENCODING_TRANSLATE, get_last_error_message() ) {
                 throw core::CoreException();
             }
@@ -2152,7 +2160,7 @@ void type_and_size_calc( INTERNAL_FUNCTION_PARAMETERS, int type )
 {
     char* size_p = NULL;
     size_t size_len = 0;
-    long size = 0;
+    int size = 0;
 
     if( zend_parse_parameters( ZEND_NUM_ARGS() TSRMLS_CC, "s", &size_p, &size_len ) == FAILURE ) {
                
@@ -2163,7 +2171,11 @@ void type_and_size_calc( INTERNAL_FUNCTION_PARAMETERS, int type )
         size = SQLSRV_SIZE_MAX_TYPE;
     }
     else {
-        _set_errno( 0 );  // reset errno for atol
+#ifdef __linux__
+        errno = 0;
+#else
+        _set_errno(0);  // reset errno for atol
+#endif
         size = atol( size_p );
         if( errno != 0 ) {
             size = SQLSRV_INVALID_SIZE;

source/sqlsrv/util.cpp

@@ -21,7 +21,9 @@
 
 #include "php_sqlsrv.h"
 
+#ifndef __linux__
 #include <windows.h>
+#endif
 
 namespace {