class Openwsman::Transport

SWIGINTERN VALUE
_wrap_Transport_auth_name(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","_WsManTransport_auth_name", 1, argv[0] ));
  } 
  arg1 = (int)(val1);
  result = (char *)_WsManTransport_auth_name(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

# File lib/openwsman/openwsman.rb, line 63
def Transport.auth_request_callback client, auth_type
  # override in client code
  # return Array of [ username, password ]
  # return nil to abort authentication
end

SWIGINTERN VALUE
_wrap_Transport_error_string(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","_WsManTransport_error_string", 1, argv[0] ));
  } 
  arg1 = (int)(val1);
  result = (char *)_WsManTransport_error_string(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_agent(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","agent", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_agent(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_agente___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_agent", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_agent", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_agent(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_auth_method(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","auth_method", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_auth_method(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_auth_methode___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_auth_method", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_auth_method", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_auth_method(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_auth_methodq___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","is_auth_method", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","is_auth_method", 2, argv[0] ));
  } 
  arg2 = (int)(val2);
  result = (int)_WsManTransport_is_auth_method(arg1,arg2);
  vresult = (result != 0) ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_auth_value(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","auth_value", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (int)_WsManTransport_auth_value(arg1);
  vresult = SWIG_From_int((int)(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_cainfo(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","cainfo", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_cainfo(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_cainfoe___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_cainfo", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_cainfo", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_cainfo(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_caoid(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","caoid", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_caoid(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_caoide___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_caoid", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_caoid", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_caoid(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_capath(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","capath", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_capath(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_capathe___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_capath", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_capath", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_capath(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_cert(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","cert", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_cert(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_certe___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_cert", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_cert", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_cert(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_certhumbprint(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","certhumbprint", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_certhumbprint(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_certhumbprinte___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_certhumbprint", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_certhumbprint", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_certhumbprint(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_close(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","close", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  _WsManTransport_close(arg1);
  return Qnil;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_key(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","key", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_key(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_keye___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_key", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_key", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_key(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_password(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","get_password", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_get_password(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_passworde___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_password", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","set_password", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_password(arg1,arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_proxy(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","proxy", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_proxy(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_proxye___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_proxy", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_proxy", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_proxy(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_proxy_password(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","get_proxy_password", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_get_proxy_password(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_proxy_passworde___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_proxy_password", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","set_proxy_password", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_proxy_password(arg1,arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_proxy_username(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","get_proxy_username", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_get_proxy_username(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_proxy_usernamee___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_proxy_username", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","set_proxy_username", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_proxy_username(arg1,arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_proxyauth(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","proxyauth", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_proxyauth(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_proxyauthe___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_proxyauth", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","set_proxyauth", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_proxyauth(arg1,(char const *)arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_timeout(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","timeout", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (unsigned long)_WsManTransport_timeout(arg1);
  vresult = SWIG_From_unsigned_SS_long((unsigned long)(result));
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_timeoute___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_timeout", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long","set_timeout", 2, argv[0] ));
  } 
  arg2 = (unsigned long)(val2);
  _WsManTransport_set_timeout(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_username(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","get_username", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (char *)_WsManTransport_get_username(arg1);
  vresult = SWIG_FromCharPtr((const char *)result);
  free(result);
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_usernamee___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_username", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","set_username", 2, argv[0] ));
  }
  arg2 = (char *)(buf2);
  _WsManTransport_set_username(arg1,arg2);
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
fail:
  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_verify_hoste___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  VALUE arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_verify_host", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  arg2 = argv[0];
  _WsManTransport_set_verify_host(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_verify_hostq___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","verify_host", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (unsigned int)_WsManTransport_verify_host(arg1);
  vresult = (result != 0) ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_verify_peere___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  VALUE arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","set_verify_peer", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  arg2 = argv[0];
  _WsManTransport_set_verify_peer(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}

SWIGINTERN VALUE
_wrap_Transport_verify_peerq___(int argc, VALUE *argv, VALUE self) {
  struct _WsManTransport *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__WsManTransport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "struct _WsManTransport *","verify_peer", 1, self )); 
  }
  arg1 = (struct _WsManTransport *)(argp1);
  result = (unsigned int)_WsManTransport_verify_peer(arg1);
  vresult = (result != 0) ? Qtrue : Qfalse;
  return vresult;
fail:
  return Qnil;
}