p4ruby 2017.1.1699426-x64-mingw32 → 2021.1.2156749-x64-mingw32

data/ext/P4/clientprogressruby.cpp

@@ -56,7 +56,6 @@ ClientProgressRuby::ClientProgressRuby(VALUE prog, int t) {
 }
 
 ClientProgressRuby::~ClientProgressRuby() {
-	rb_gc_mark( progress );
 }
 
 void ClientProgressRuby::Description(const StrPtr *d, int u) {

data/ext/P4/clientuserruby.cpp

@@ -38,6 +38,7 @@
 #include <ruby.h>
 #include "undefdups.h"
 #include <p4/clientapi.h>
+#include <p4/strtable.h>
 #include <p4/clientprog.h>
 #include <p4/spec.h>
 #include <p4/diff.h>
@@ -77,6 +78,7 @@ ClientUserRuby::ClientUserRuby(SpecMgr *s) {
 	rubyExcept = 0;
 	alive = 1;
 	track = false;
+    SetSSOHandler( ssoHandler = new P4ClientSSO( s ) );
 
 	ID idP4 = rb_intern("P4");
 	ID idP4OH = rb_intern("OutputHandler");
@@ -723,4 +725,157 @@ void ClientUserRuby::GCMark() {
 	rb_gc_mark( cProgress );
 
 	results.GCMark();
+	ssoHandler->GCMark();
 }
+
+//
+// SSO handler
+//
+
+P4ClientSSO::P4ClientSSO( SpecMgr *s )
+{
+    specMgr = s;
+    resultSet = 0;
+    ssoEnabled = 0;
+    result = Qnil;
+}
+
+ClientSSOStatus
+P4ClientSSO::Authorize( StrDict &vars, int maxLength, StrBuf &strbuf )
+{
+    ssoVars.Clear();
+
+    if( !ssoEnabled )
+        return CSS_SKIP;
+
+    if( ssoEnabled < 0 )
+        return CSS_UNSET;
+
+    if( resultSet )
+    {
+        strbuf.Clear();
+		VALUE resval = result;
+
+        //if( P4RDB_CALLS )
+        //    std::cerr << "[P4] ClientSSO::Authorize(). Using supplied input"
+        //              << std::endl;
+
+		if (Qtrue == rb_obj_is_kind_of(result, rb_cArray)) {
+			resval = rb_ary_shift(result);
+		}
+	
+		if( resval != Qnil ) {
+			// Convert whatever's left into a string
+			ID to_s = rb_intern("to_s");
+			VALUE str = rb_funcall(resval, to_s, 0);
+			strbuf.Set(StringValuePtr(str));
+		}
+
+        return resultSet == 2 ? CSS_FAIL
+                              : CSS_PASS;
+    }
+
+    ssoVars.CopyVars( vars );
+    return CSS_EXIT;
+}
+
+VALUE
+P4ClientSSO::EnableSSO( VALUE e )
+{
+    if( e == Qnil )
+    {
+        ssoEnabled = 0;
+        return Qtrue;
+    }
+
+    if( e == Qtrue )
+    {
+        ssoEnabled = 1;
+        return Qtrue;
+    }
+
+    if( e == Qfalse )
+    {
+        ssoEnabled = -1;
+        return Qtrue;
+    }
+
+	return Qfalse;
+}
+
+VALUE
+P4ClientSSO::SSOEnabled()
+{
+    if( ssoEnabled == 1 )
+    {
+        return Qtrue;
+    }
+    else if( ssoEnabled == -1 )
+    {
+        return Qfalse;
+    }
+    else
+    {
+        return Qnil;
+    }
+}
+
+VALUE
+P4ClientSSO::SetPassResult( VALUE i )
+{
+    resultSet = 1;
+    return SetResult( i );
+}
+
+VALUE
+P4ClientSSO::GetPassResult()
+{
+    if( resultSet == 1 )
+    {
+        return result;
+    }
+    else
+    {
+        return Qnil;
+    }
+}
+
+VALUE
+P4ClientSSO::SetFailResult( VALUE i )
+{
+    resultSet = 2;
+    return SetResult( i );
+}
+
+VALUE
+P4ClientSSO::GetFailResult()
+{
+    if( resultSet == 2 )
+    {
+        return result;
+    }
+    else
+    {
+        return Qnil;
+    }
+}
+
+VALUE
+P4ClientSSO::SetResult( VALUE i )
+{
+	//if (P4RDB_CALLS) fprintf(stderr, "[P4] P4ClientSSO::SetResult()\n");
+ 
+	result = i;
+	return Qtrue;
+}
+
+VALUE
+P4ClientSSO::GetSSOVars()
+{
+    return specMgr->StrDictToHash( &ssoVars );
+}
+
+void
+P4ClientSSO::GCMark() {
+	if (result != Qnil) rb_gc_mark( result );
+}

data/ext/P4/clientuserruby.h

@@ -42,6 +42,39 @@
 class SpecMgr;
 class ClientProgress;
 
+class P4ClientSSO : public ClientSSO
+{
+    public:
+        P4ClientSSO( SpecMgr *s );
+
+    // Client SSO methods overridden here
+    virtual ClientSSOStatus Authorize( StrDict &vars, int maxLength,
+                                       StrBuf &result );
+
+    // Local methods
+    VALUE EnableSSO( VALUE e );
+    VALUE SSOEnabled();
+    VALUE SetPassResult( VALUE i );
+    VALUE GetPassResult();
+    VALUE SetFailResult( VALUE i );
+    VALUE GetFailResult();
+    VALUE GetSSOVars();
+
+	void GCMark();
+
+    private:
+
+    VALUE SetResult( VALUE i );
+
+    int         ssoEnabled;
+    int         resultSet;
+
+    StrBufDict  ssoVars;
+    SpecMgr *   specMgr;
+
+    VALUE       result;
+};
+
 class ClientUserRuby: public ClientUser, public KeepAlive {
 public:
 	ClientUserRuby(SpecMgr *s);
@@ -101,6 +134,16 @@ public:
 		return progress;
 	}
 
+	// SSO handler support
+
+    VALUE EnableSSO( VALUE e )        { return ssoHandler->EnableSSO( e ); }
+    VALUE SSOEnabled()   { return ssoHandler->SSOEnabled(); }
+    VALUE SetSSOPassResult( VALUE i ) { return ssoHandler->SetPassResult( i ); }
+    VALUE GetSSOPassResult(){ return ssoHandler->GetPassResult();}
+    VALUE SetSSOFailResult( VALUE i ) { return ssoHandler->SetFailResult( i ); }
+    VALUE GetSSOFailResult(){ return ssoHandler->GetFailResult();}
+    VALUE GetSSOVars()  { return ssoHandler->GetSSOVars(); }
+
 	// override from KeepAlive
 	virtual int IsAlive() {
 		return alive;
@@ -129,5 +172,6 @@ private:
 	int alive;
 	int rubyExcept;
 	bool track;
+    P4ClientSSO * ssoHandler;
 };
 

data/ext/P4/extconf.rb

@@ -6,10 +6,19 @@ require 'mkmf'
 require 'net/ftp'
 require 'P4/version'
 require 'rbconfig'
+require 'openssl'
 
 # Set this to the main version directory we look up in ftp.perforce.com for the P4API
 # This is ignored if you specify the version on the command line.
-P4API_VERSION_DIR = 'r17.2'
+# Changed the hardcoded string so that the version is now derived from version.rb file
+#P4API_VERSION_DIR = 'r19.1'
+def p4api_version_dir
+        ver=P4::Version.split(".")
+        p4_major = ver[0].chars.last(2).join
+        p4_minor = ver[1]
+        dir = "r" + p4_major + "." + p4_minor
+end
+
 
 #==============================================================================
 # Provide platform variables in P4-specific format
@@ -102,6 +111,15 @@ def calculate_p4osver
   return ver
 end
 
+def gcc
+  @gcc ||= calculate_gcc
+end
+
+def calculate_gcc
+  gcc = RbConfig::CONFIG["GCC"]
+  return gcc
+end
+
 def uname_platform
   @uname_platform ||= calculate_uname_platform
 end
@@ -155,6 +173,13 @@ def set_platform_opts
   end
 end
 
+def set_platform_cxxflags
+  if (p4osname == 'LINUX') && (gcc == 'yes')
+    $CXXFLAGS += " -std=c++11 "
+  end
+end
+
+
 def set_platform_cppflags
   $CPPFLAGS += "-DOS_#{p4osname} "
   $CPPFLAGS += "-DOS_#{p4osname}#{p4osver} "
@@ -214,6 +239,7 @@ def set_platform_libs
         $LDFLAGS += ' -framework CoreFoundation -framework Foundation'
       end
     when 'LINUX', 'MINGW32'
+      $LDFLAGS += ' -Wl,--allow-multiple-definition'
       have_library('supc++')
   end
 end
@@ -399,6 +425,8 @@ def p4_cpu(os)
     when :darwin, :linux
       if cpu =~ /i686/
         'x86'
+      elsif cpu =~ /universal/
+        'x86_64'
       else
         cpu
       end
@@ -425,7 +453,9 @@ def p4_platform_label
       else
         'mingwx86'
       end
-    when /darwin/
+    when /darwin19|darwin[2-9][0-9]/
+      "macosx1015#{p4_cpu(:darwin)}"
+    when /darwin/      
       "darwin90#{p4_cpu(:darwin)}"
     when /solaris/
       "solaris10#{p4_cpu(:solaris)}"
@@ -445,13 +475,36 @@ def ftp_download_dir(version)
 end
 
 def filename
+  openssl_number = OpenSSL::OPENSSL_VERSION.split(' ')[1].to_s
+  openssl_number = openssl_number.slice(0, (openssl_number.rindex('.')))
+
   if RbConfig::CONFIG['target_os'].downcase =~ /nt|mswin|mingw/
-    'p4api.zip'
+    filename = 'p4api.zip'
+    if !openssl_number.to_s.empty?
+        case openssl_number.to_s
+            when /1.1/
+                filename = 'p4api-openssl1.1.1.zip'
+            when /1.0/
+                filename = 'p4api-openssl1.0.2.zip'
+             end
+    end
+  elsif RbConfig::CONFIG['target_os'].downcase =~ /darwin19|darwin[2-9][0-9]/
+    filename = 'p4api-openssl1.1.1.tgz'
   else
-    'p4api.tgz'
+    filename = 'p4api.tgz'
+    if !openssl_number.to_s.empty?
+        case openssl_number.to_s
+            when /1.1/
+                filename = 'p4api-glibc2.3-openssl1.1.1.tgz'
+            when /1.0/
+                filename = 'p4api-glibc2.3-openssl1.0.2.tgz'
+        end
+    end
   end
+  return filename
 end
 
+
 def remote_files_matching(ftp, dir, regex)
   ftp.ls(dir.to_s).map { |entry|
     if match = entry.match(regex)
@@ -499,9 +552,8 @@ def download_api_via_ftp
   # At one point, we allowed the gem build to just find the most recent p4api build.
   # P4Ruby probably shouldn't do that by default.
   #version_dir = find_latest_version_dir(ftp)
-  version_dir = P4API_VERSION_DIR
 
-  dir = ftp_download_dir(version_dir)
+  dir = ftp_download_dir(p4api_version_dir)
   ftp.chdir(dir)
 
   puts "downloading #{filename} from #{dir} on ftp.perforce.com"
@@ -536,9 +588,11 @@ set_platform_opts
 # based solely on platform detection.
 set_platform_cppflags
 set_platform_cflags
+set_platform_cxxflags
 
 puts "$CPPFLAGS #{$CPPFLAGS}"
 puts "$CFLAGS #{$CFLAGS}"
+puts "$CXXFLAGS #{$CXXFLAGS}"
 
 # Setup additional system library definitions based on platform type before
 # we setup other libraries, in order to preserve linking order
@@ -554,15 +608,17 @@ resolve_ssl_dirs
 # If we happen to need SSL on Windows, we also need gdi32
 if RbConfig::CONFIG['target_os'].downcase =~ /mingw/
   have_library('gdi32') or raise
+  have_library('ole32') or raise
+  have_library('crypt32') or raise
 end
 
-do_ssl = have_library('crypto') and have_library('ssl')
-
-unless do_ssl
-  have_library('p4sslstub') or raise
-end
-
+have_library('crypto') or raise
+have_library('ssl') or raise
 have_library('supp') or raise
+have_library('p4script_sqlite') or raise
+have_library('p4script_curl') or raise
+have_library('p4script') or raise
+have_library('p4script_c') or raise
 have_library('rpc') or raise
 have_library('client') or raise
 
@@ -577,4 +633,4 @@ create_p4rubyconf_header(version_info, $libs)
 # don't believe we need to rely on actually.
 create_header
 
-create_makefile('P4')
+create_makefile('P4')

data/ext/P4/p4.cpp

@@ -314,6 +314,25 @@ static VALUE p4_set_enviro_file( VALUE self, VALUE rbstr )
     return Qtrue;
 }
 
+static VALUE p4_get_evar( VALUE self, VALUE var )
+{
+    P4ClientApi	*p4;
+    const StrPtr *val;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    val = p4->GetEVar( StringValuePtr( var ) );
+    if( !val ) return Qnil;
+
+    return P4Utils::ruby_string( val->Text() );
+}
+
+static VALUE p4_set_evar( VALUE self, VALUE var, VALUE val )
+{
+    P4ClientApi *p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    p4->SetEVar( StringValuePtr( var ), StringValuePtr( val ) );
+    return Qtrue;
+}
+
 static VALUE p4_get_host( VALUE self )
 {
     P4ClientApi	*p4;
@@ -642,7 +661,7 @@ static VALUE p4_run( VALUE self, VALUE args )
 
     // Allocate storage on the stack so it's automatically reclaimed
     // when we exit.
-    char **p4args = ALLOCA_N( char *, argc + 1 );
+    char **p4args = RB_ALLOC_N( char *, argc + 1 );
 
     // Copy the args across
     for ( i = 0; i < argc; i++ )
@@ -679,13 +698,6 @@ static VALUE p4_get_messages( VALUE self )
     return p4->GetMessages();
 }
 
-static VALUE p4_reset( VALUE self )
-{
-    P4ClientApi *p4;
-    Data_Get_Struct( self, P4ClientApi, p4 );
-    return p4->Reset();
-}
-
 static VALUE p4_get_warnings( VALUE self )
 {
     P4ClientApi	*p4;
@@ -815,6 +827,58 @@ static VALUE p4_set_progress( VALUE self, VALUE progress )
     return p4->SetProgress( progress );
 }
 
+/*******************************************************************************
+ * SSO handler support
+ ******************************************************************************/
+static VALUE p4_get_enabled_sso( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetEnableSSO();
+}
+
+static VALUE p4_set_enable_sso( VALUE self, VALUE enable )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->SetEnableSSO( enable );
+}
+
+static VALUE p4_get_sso_vars( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetSSOVars();
+}
+
+static VALUE p4_get_sso_passresult( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetSSOPassResult();
+}
+
+static VALUE p4_set_sso_passresult( VALUE self, VALUE result )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->SetSSOPassResult( result );
+}
+
+static VALUE p4_get_sso_failresult( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetSSOFailResult();
+}
+
+static VALUE p4_set_sso_failresult( VALUE self, VALUE result )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->SetSSOFailResult( result );
+}
+
 /*******************************************************************************
  * P4::MergeData methods. Construction/destruction defined elsewhere
  ******************************************************************************/
@@ -1269,6 +1333,8 @@ void	Init_P4()
     rb_define_method( cP4, "set_env", 	RUBY_METHOD_FUNC(p4_set_env)     , 2 );
     rb_define_method( cP4, "enviro_file", RUBY_METHOD_FUNC(p4_get_enviro_file), 0);
     rb_define_method( cP4, "enviro_file=", RUBY_METHOD_FUNC(p4_set_enviro_file), 1);
+    rb_define_method( cP4, "evar", 	RUBY_METHOD_FUNC(p4_get_evar)     , 1 );
+    rb_define_method( cP4, "set_evar", 	RUBY_METHOD_FUNC(p4_set_evar)     , 2 );
     rb_define_method( cP4, "host", 	RUBY_METHOD_FUNC(p4_get_host)    , 0 );
     rb_define_method( cP4, "host=", 	RUBY_METHOD_FUNC(p4_set_host)    , 1 );
     rb_define_method( cP4, "ignore_file",RUBY_METHOD_FUNC(p4_get_ignore) , 0 );
@@ -1305,7 +1371,6 @@ void	Init_P4()
     rb_define_method( cP4, "connect", 	RUBY_METHOD_FUNC(p4_connect)     , 0 );
     rb_define_method( cP4, "connected?",RUBY_METHOD_FUNC(p4_connected)   , 0 );
     rb_define_method( cP4, "disconnect", RUBY_METHOD_FUNC(p4_disconnect) , 0 );
-    rb_define_method( cP4, "reset",  RUBY_METHOD_FUNC(p4_reset), 0 );
 
     // Running commands - general purpose commands
     rb_define_method( cP4, "run", 	RUBY_METHOD_FUNC(p4_run)         ,-2 );
@@ -1343,6 +1408,16 @@ void	Init_P4()
     rb_define_method( cP4, "progress", RUBY_METHOD_FUNC(p4_get_progress), 0);
     rb_define_method( cP4, "progress=", RUBY_METHOD_FUNC(p4_set_progress), 1);
 
+    // SSO handling
+    rb_define_method( cP4, "loginsso", RUBY_METHOD_FUNC(p4_get_enabled_sso), 0);
+    rb_define_method( cP4, "loginsso=", RUBY_METHOD_FUNC(p4_set_enable_sso), 1);
+    rb_define_method( cP4, "ssovars", RUBY_METHOD_FUNC(p4_get_sso_vars), 0);
+    rb_define_method( cP4, "ssopassresult", RUBY_METHOD_FUNC(p4_get_sso_passresult), 0);
+    rb_define_method( cP4, "ssopassresult=", RUBY_METHOD_FUNC(p4_set_sso_passresult), 1);
+    rb_define_method( cP4, "ssofailresult", RUBY_METHOD_FUNC(p4_get_sso_failresult), 0);
+    rb_define_method( cP4, "ssofailresult=", RUBY_METHOD_FUNC(p4_set_sso_failresult), 1);
+
+
     // P4::MergeData class
     cP4MD = rb_define_class_under( cP4, "MergeData", rb_cObject );