view release on metacpan or  search on metacpan

SSH2.xs  view on Meta::CPAN

net_ss_debug(SV*, IV debug)
CODE:
    net_ss_debug_out = debug & 1;  /* allow for future flags */

void
net_ss_version(...)
PPCODE:
    EXTEND(SP, 3);
    ST(0) = sv_2mortal(newSVpv(LIBSSH2_VERSION, 0));
    if (GIMME_V != G_ARRAY)
        XSRETURN(1);
#ifdef LIBSSH2_VERSION_NUM
    ST(1) = sv_2mortal(newSVuv(LIBSSH2_VERSION_NUM));
#else
    ST(1) = &PL_sv_undef;
#endif
    ST(2) = sv_2mortal(newSVpv(LIBSSH2_SSH_DEFAULT_BANNER, 0));
    XSRETURN(3);

SSH2_NERROR
net_ss_banner(SSH2* ss, SSH2_CHARP banner)
PREINIT:
    SV* full_banner;
CODE:
    full_banner = sv_2mortal(newSVpvf("SSH-2.0-%s", banner));
    RETVAL = libssh2_banner_set(ss->session, SvPVbyte_nolen(full_banner));
    save_eagain(ss->session, RETVAL);
OUTPUT:
    RETVAL

SSH2_ERROR
net_ss_error(SSH2* ss)
PREINIT:
    char* errstr;
    int errlen;
CODE:
    RETVAL = libssh2_session_last_error(ss->session, &errstr, &errlen, 0);
    if(GIMME_V == G_ARRAY) {
        SV *errcode_sv;
        if (RETVAL == LIBSSH2_ERROR_NONE)
            XSRETURN_EMPTY;
        EXTEND(SP, 3);
        ST(0) = sv_2mortal(newSViv(RETVAL));
        if ((-RETVAL > 0) && (-RETVAL < countof(xs_libssh2_error)))
            errcode_sv = newSVpvf("LIBSSH2_ERROR_%s", xs_libssh2_error[-RETVAL]);
        else
            errcode_sv = newSVpvf("LIBSSH2_ERROR_UNKNOWN(%d)", RETVAL);
        ST(1) = sv_2mortal(errcode_sv);
        ST(2) = (errstr ? sv_2mortal(newSVpvn(errstr, errlen)) : &PL_sv_undef);
        XSRETURN(3);
    }
OUTPUT:
    RETVAL

void
net_ss__set_error(SSH2 *ss, int errcode = 0, SSH2_CHARP_OR_NULL errmsg = NULL)
CODE:
    libssh2_session_set_last_error(ss->session, errcode, errmsg);

SSH2_NERROR
net_ss__method(SSH2* ss, SSH2_METHOD type, SSH2_CHARP_OR_NULL prefs = NULL)
CODE:
    /* if there are no other parameters, return the current value */
    if (items == 2) {
        const char *method = libssh2_session_methods(ss->session, (int)type);
        if (!method)
            XSRETURN_EMPTY;
        XSRETURN_PV(method);
    }
    RETVAL = libssh2_session_method_pref(ss->session,
                                         (int)type, prefs);
    save_eagain(ss->session, RETVAL);
OUTPUT:
    RETVAL

#if LIBSSH2_VERSION_NUM >= 0x010200

SSH2_NERROR
net_ss_flag(SSH2* ss, SSH2_FLAG flag, int value)
CODE:
    RETVAL = libssh2_session_flag(ss->session, (int)flag, value);
    save_eagain(ss->session, RETVAL);
OUTPUT:
    RETVAL

#else

void
net_ss_flag(SSH2* ss, SV* flag, int value)
CODE:
    croak("libssh2 version 1.2 or higher required for flag support");

#endif

SSH2_RC
net_ss_callback(SSH2* ss, SSH2_CALLBACK type, SV* callback = NULL)
CODE:
    if (callback && !SvOK(callback))
        callback = NULL;
    if (callback && !(SvROK(callback) && SvTYPE(SvRV(callback)) == SVt_PVCV))
        croak("%s::callback: callback must be CODE ref", class);
    if (type < 0 || type >= countof(msg_cb))
        croak("%s::callback: don't know how to handle: %s",
              class, SvPVbyte_nolen(callback));

    ss->sv_ss = SvRV(ST(0));  /* don't keep a reference, just store it */
    SvREFCNT_dec(ss->rgsv_cb[type]);
    libssh2_session_callback_set(ss->session,
     type, callback ? cb_as_void_ptr(msg_cb[type]) : NULL);
    SvREFCNT_inc(callback);
    ss->rgsv_cb[type] = callback;
    RETVAL = 1;
OUTPUT:
    RETVAL

SSH2_NERROR
net_ss__startup(SSH2* ss, int fd, SV *socket, SV* hostname, int port)
CODE:
    RETVAL = libssh2_session_startup(ss->session, fd);
    if ((RETVAL >= 0) && SvOK(socket)) {
        if (ss->socket)
            sv_2mortal(ss->socket);
        ss->socket = newSVsv(socket);
        ss->hostname = newSVsv(hostname);
        ss->port = port;
    }
    save_eagain(ss->session, RETVAL);
OUTPUT:
    RETVAL

SV *