p4ruby 2019.1.1873991 → 2021.1.2196401

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>
@@ -65,6 +66,19 @@ static const int CANCEL = 2;
  * server, and converts the data to Ruby form for returning to the caller.
  ******************************************************************************/
 
+class SSOShim : public ClientSSO {
+public:
+	SSOShim(ClientUserRuby *ui) : ui(ui) {}
+	virtual ClientSSOStatus	Authorize( StrDict &vars,
+				           int maxLength,
+				           StrBuf &result )
+	{
+		return ui->Authorize(vars, maxLength, result);
+	}
+private:
+	ClientUserRuby *ui;
+} ;
+
 ClientUserRuby::ClientUserRuby(SpecMgr *s) {
 	specMgr = s;
 	debug = 0;
@@ -77,14 +91,22 @@ ClientUserRuby::ClientUserRuby(SpecMgr *s) {
 	rubyExcept = 0;
 	alive = 1;
 	track = false;
+    	SetSSOHandler( new SSOShim( this ) );
+
+	ssoEnabled = 0;
+	ssoResultSet = 0;
+	ssoResult = Qnil;
+	ssoHandler = Qnil;
 
 	ID idP4 = rb_intern("P4");
 	ID idP4OH = rb_intern("OutputHandler");
 	ID idP4Progress = rb_intern("Progress");
+	ID idP4SSO = rb_intern("SSOHandler");
 
 	VALUE cP4 = rb_const_get_at(rb_cObject, idP4);
 	cOutputHandler = rb_const_get_at(cP4, idP4OH);
 	cProgress = rb_const_get_at(cP4, idP4Progress );
+	cSSOHandler = rb_const_get_at(cP4, idP4SSO);
 }
 
 void ClientUserRuby::Reset() {
@@ -719,8 +741,239 @@ void ClientUserRuby::GCMark() {
 	if (mergeResult != Qnil) rb_gc_mark( mergeResult);
 	if (handler != Qnil) rb_gc_mark( handler);
 	if (progress != Qnil) rb_gc_mark( progress );
-	rb_gc_mark( cOutputHandler);
+	if (ssoResult != Qnil) rb_gc_mark( ssoResult );
+	if (ssoHandler != Qnil) rb_gc_mark( ssoHandler );
+	rb_gc_mark( cOutputHandler );
 	rb_gc_mark( cProgress );
+	rb_gc_mark( cSSOHandler );
 
 	results.GCMark();
 }
+
+
+/*
+ * Set the Handler object. Double-check that it is either nil or
+ * an instance of OutputHandler to avoid future problems
+ */
+
+VALUE
+ClientUserRuby::SetRubySSOHandler(VALUE h) {
+	if (P4RDB_CALLS) fprintf(stderr, "[P4] SetSSOHandler()\n");
+
+	if (Qnil != h && Qfalse == rb_obj_is_kind_of(h, cSSOHandler)) {
+		rb_raise(eP4, "Handler needs to be an instance of P4::SSOHandler");
+		return Qfalse;
+	}
+
+	ssoHandler = h;
+	alive = 1; // ensure that we don't drop out after the next call
+
+	return Qtrue;
+}
+
+
+// returns true if output should be reported
+// false if the output is handled and should be ignored
+static VALUE CallMethodSSO(VALUE data) {
+	VALUE *args = reinterpret_cast<VALUE *>(data);
+	return rb_funcall(args[0], (ID) rb_intern("authorize"), 2, args[1], args[2]);
+}
+
+ClientSSOStatus
+ClientUserRuby::CallSSOMethod(VALUE vars, int maxLength, StrBuf &result) {
+	ClientSSOStatus answer = CSS_SKIP;
+	int excepted = 0;
+	result.Clear();
+
+	if (P4RDB_COMMANDS) fprintf(stderr, "[P4] CallSSOMethod\n");
+
+	// some wild hacks to satisfy the rb_protect method
+
+	VALUE args[3] = { ssoHandler, vars, INT2NUM( maxLength ) };
+
+	VALUE res = rb_protect(CallMethodSSO, (VALUE) args, &excepted);
+
+	if (excepted) { // exception thrown
+		alive = 0;
+		rb_jump_tag(excepted);
+	} else if( FIXNUM_P( res ) ) {
+		int a = NUM2INT(res);
+		if (P4RDB_COMMANDS)
+			fprintf(stderr, "[P4] CallSSOMethod returned %d\n", a);
+
+		if( a < CSS_PASS || a > CSS_SKIP )
+			rb_raise(eP4, "P4::SSOHandler::authorize returned out of range response");
+		answer = (ClientSSOStatus) a;
+	} else if( Qtrue == rb_obj_is_kind_of(res, rb_cArray) ) {
+		VALUE resval1 = rb_ary_shift(res);
+		Check_Type( resval1, T_FIXNUM );
+		int a = NUM2INT(resval1);
+		if( a < CSS_PASS || a > CSS_SKIP )
+			rb_raise(eP4, "P4::SSOHandler::authorize returned out of range response");
+		answer = (ClientSSOStatus) a;
+
+		VALUE resval2 = rb_ary_shift(res);
+		if( resval2 != Qnil )
+		{
+			Check_Type( resval2, T_STRING );
+			result.Set(StringValuePtr(resval2));
+			if (P4RDB_COMMANDS)
+				fprintf(stderr, "[P4] CallSSOMethod returned %d, %s\n", a, result.Text());
+		}
+
+	} else {
+		Check_Type( res, T_STRING );
+		answer = CSS_PASS;
+
+		result.Set(StringValuePtr(res));
+		if (P4RDB_COMMANDS)
+			fprintf(stderr, "[P4] CallSSOMethod returned %s\n", result.Text());
+
+	}
+
+	return answer;
+}
+
+ClientSSOStatus
+ClientUserRuby::Authorize( StrDict &vars, int maxLength, StrBuf &strbuf )
+{
+	ssoVars.Clear();
+
+	if( ssoHandler != Qnil )
+	{
+		ClientSSOStatus res = CallSSOMethod( specMgr->StrDictToHash(&vars), maxLength, strbuf );
+		if( res != CSS_SKIP )
+			return res;
+		if (P4RDB_COMMANDS)
+			fprintf(stderr, "[P4] Authorize skipped result from SSO Handler\n" );
+	}
+
+	if( !ssoEnabled )
+		return CSS_SKIP;
+
+	if( ssoEnabled < 0 )
+		return CSS_UNSET;
+
+	if( ssoResultSet )
+	{
+		strbuf.Clear();
+			VALUE resval = ssoResult;
+
+		//if( P4RDB_CALLS )
+		//    std::cerr << "[P4] ClientSSO::Authorize(). Using supplied input"
+		//              << std::endl;
+
+		if (Qtrue == rb_obj_is_kind_of(ssoResult, rb_cArray)) {
+			resval = rb_ary_shift(ssoResult);
+		}
+	
+		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 ssoResultSet == 2 ? CSS_FAIL
+				: CSS_PASS;
+	}
+
+	ssoVars.CopyVars( vars );
+	return CSS_EXIT;
+}
+
+VALUE
+ClientUserRuby::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
+ClientUserRuby::SSOEnabled()
+{
+	if( ssoEnabled == 1 )
+	{
+		return Qtrue;
+	}
+	else if( ssoEnabled == -1 )
+	{
+		return Qfalse;
+	}
+	else
+	{
+		return Qnil;
+	}
+}
+
+VALUE
+ClientUserRuby::SetSSOPassResult( VALUE i )
+{
+	ssoResultSet = 1;
+	return SetSSOResult( i );
+}
+
+VALUE
+ClientUserRuby::GetSSOPassResult()
+{
+	if( ssoResultSet == 1 )
+	{
+		return ssoResult;
+	}
+	else
+	{
+		return Qnil;
+	}
+}
+
+VALUE
+ClientUserRuby::SetSSOFailResult( VALUE i )
+{
+	ssoResultSet = 2;
+	return SetSSOResult( i );
+}
+
+VALUE
+ClientUserRuby::GetSSOFailResult()
+{
+	if( ssoResultSet == 2 )
+	{
+		return ssoResult;
+	}
+	else
+	{
+		return Qnil;
+	}
+}
+
+VALUE
+ClientUserRuby::SetSSOResult( VALUE i )
+{
+	if (P4RDB_CALLS) fprintf(stderr, "[P4] P4ClientSSO::SetResult()\n");
+ 
+	ssoResult = i;
+	return Qtrue;
+}
+
+VALUE
+ClientUserRuby::GetSSOVars()
+{
+    	return specMgr->StrDictToHash( &ssoVars );
+}

data/ext/P4/clientuserruby.h

@@ -42,7 +42,7 @@
 class SpecMgr;
 class ClientProgress;
 
-class ClientUserRuby: public ClientUser, public KeepAlive {
+class ClientUserRuby: public ClientUser, public ClientSSO, public KeepAlive {
 public:
 	ClientUserRuby(SpecMgr *s);
 
@@ -101,6 +101,21 @@ public:
 		return progress;
 	}
 
+	// SSO handler support
+
+	virtual ClientSSOStatus Authorize( StrDict &vars, int maxLength, StrBuf &result );
+	VALUE EnableSSO( VALUE e );
+	VALUE SSOEnabled();
+	VALUE SetSSOPassResult( VALUE i );
+	VALUE GetSSOPassResult();
+	VALUE SetSSOFailResult( VALUE i );
+	VALUE GetSSOFailResult();
+	VALUE GetSSOVars();
+	VALUE SetRubySSOHandler( VALUE handler );
+	VALUE GetRubySSOHandler() {
+		return ssoHandler;
+	}
+
 	// override from KeepAlive
 	virtual int IsAlive() {
 		return alive;
@@ -112,6 +127,8 @@ private:
 	void ProcessOutput(const char * method, VALUE data);
 	void ProcessMessage(Error * e);
 	bool CallOutputMethod(const char * method, VALUE data);
+	VALUE SetSSOResult( VALUE i );
+	ClientSSOStatus CallSSOMethod(VALUE vars, int maxLength, StrBuf &result);
 
 private:
 	StrBuf cmd;
@@ -124,10 +141,18 @@ private:
 	VALUE cOutputHandler;
 	VALUE progress;
 	VALUE cProgress;
+	VALUE cSSOHandler;
 	int debug;
 	int apiLevel;
 	int alive;
 	int rubyExcept;
 	bool track;
+	
+	// SSO handler support
+	int         ssoEnabled;
+	int         ssoResultSet;
+	StrBufDict  ssoVars;
+	VALUE       ssoResult;
+	VALUE 	    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 = 'r19.1'
+# 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} "
@@ -400,6 +425,8 @@ def p4_cpu(os)
     when :darwin, :linux
       if cpu =~ /i686/
         'x86'
+      elsif cpu =~ /universal/
+        'x86_64'
       else
         cpu
       end
@@ -417,23 +444,19 @@ end
 # directory name where we can download files from.
 def p4_platform_label
   case RbConfig::CONFIG["target_os"].downcase
-    when /nt|mswin|mingw/
+    when /nt|mswin|mingw|cygwin|msys/
       # Ruby on windows is only MinGW via Rubyinstaller.org, though this may
       # not work on all rubies.
-      if RbConfig::CONFIG['MAJOR'].to_i >= 2
-        # Note that x64 or x86 needs to be suffixed to this
-        'mingw64'
-      else
-        'mingwx86'
-      end
-    when /darwin/
+      # There are too many permutations of Windows p4api, to automate.
+      raise 'Automatic fetching of p4api from perforce FTP is not supported on Windows'
+    when /darwin19|darwin[2-9][0-9]/
+      "macosx1015#{p4_cpu(:darwin)}"
+    when /darwin/      
       "darwin90#{p4_cpu(:darwin)}"
     when /solaris/
       "solaris10#{p4_cpu(:solaris)}"
     when /linux/
-      "linux26#{p4_cpu(:linux)}"
-    when /cygwin/
-      raise 'cygwin is not supported for the --download-p4api option'
+      "linux26#{p4_cpu(:linux)}"    
   end
 end
 
@@ -446,13 +469,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)
@@ -500,9 +546,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"
@@ -537,9 +582,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
@@ -556,14 +603,11 @@ resolve_ssl_dirs
 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

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,72 @@ 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 );
+}
+static VALUE p4_get_ssohandler( VALUE self )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    return p4->GetSSOHandler();
+}
+
+static VALUE p4_set_ssohandler( VALUE self, VALUE handler )
+{
+    P4ClientApi	*p4;
+    Data_Get_Struct( self, P4ClientApi, p4 );
+    p4->SetSSOHandler( handler );
+    return Qtrue;
+}
+
 /*******************************************************************************
  * P4::MergeData methods. Construction/destruction defined elsewhere
  ******************************************************************************/
@@ -1269,6 +1347,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 +1385,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 +1422,18 @@ 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);
+    rb_define_method( cP4, "ssohandler", RUBY_METHOD_FUNC(p4_get_ssohandler), 0);
+    rb_define_method( cP4, "ssohandler=", RUBY_METHOD_FUNC(p4_set_ssohandler), 1);
+
+
     // P4::MergeData class
     cP4MD = rb_define_class_under( cP4, "MergeData", rb_cObject );