view release on metacpan or  search on metacpan

NSS.xs  view on Meta::CPAN

    if (value == NULL) {
        /* Failed to get key, return default */
        return default_value;
    }
    
    return (PRBool) SvTRUE(*value);
}

MODULE = Crypt::NSS     PACKAGE = Crypt::NSS::PrivateKey

void
DESTROY(self)
    Crypt::NSS::PrivateKey self;
    CODE:
        if (self != NULL) {
            SECKEY_DestroyPrivateKey(self);
        }

MODULE = Crypt::NSS        PACKAGE = Net::NSS::SSL

Net::NSS::SSL
create_socket(pkg, type)
    const char * pkg;
    const char * type;
    PREINIT:
        NSS_SSL_Socket * socket;
    CODE:
        Newz(1, socket, 1, NSS_SSL_Socket);
        if (strEQ(type, "tcp")) {
            socket->fd = PR_NewTCPSocket();
        }
        else if (strEQ(type, "udp")) {
            socket->fd = PR_NewUDPSocket();
        }
        else {
            croak("Unknown socket type '%s'. Valid types are are 'tcp' and 'udp'", type);
        }

        if (socket->fd == NULL) {
            throw_exception_from_nspr_error("Failed to create new TCP socket");
        }        

        socket->is_connected = FALSE;
        RETVAL = socket;
    OUTPUT:
        RETVAL

void 
set_option(self, option, value)
    Net::NSS::SSL self;
    SV * option;
    I32 value;
    PREINIT:
        char * name;
        I32 num;
        PRSocketOptionData sock_opt;
    CODE:
        if (SvPOK(option)) {
            name = SvPV_nolen(option);
            if (strEQ(name, "KeepAlive")) {
                sock_opt.option = PR_SockOpt_Keepalive;
                sock_opt.value.keep_alive = value ? PR_TRUE : PR_FALSE;
            }
            else if (strEQ(name, "NoDelay")) {
                sock_opt.option = PR_SockOpt_NoDelay;
                sock_opt.value.no_delay = value ? PR_TRUE : PR_FALSE;
            }
            else if (strEQ(name, "Blocking")) {
                sock_opt.option = PR_SockOpt_Nonblocking;
                sock_opt.value.non_blocking = value ? PR_FALSE : PR_TRUE;
            }
            else {
                croak("Unknown option '%s'", option);
            }
            
            SET_SOCKET_OPTION(self->fd, sock_opt, form("Failed to set option '%s' on socket", option));
        }
        else if (SvIOK(option)) {
            EVALUATE_SEC_CALL(SSL_OptionSet(self->ssl_fd, SvIV(option), value), "Failed to set option")
        }

SV *
get_option(self, option)
    Net::NSS::SSL self;
    SV * option;
    PREINIT:
        char * name;
        I32 num;
        PRSocketOptionData sock_opt;
        PRBool on;
    CODE:
        if (SvPOK(option)) {
            name = SvPV_nolen(option);
            if (strEQ(name, "KeepAlive")) {
                sock_opt.option = PR_SockOpt_Keepalive;
                GET_SOCKET_OPTION(self->fd, sock_opt, option);
                RETVAL = boolSV(sock_opt.value.keep_alive ? TRUE : FALSE);
            }
            else if (strEQ(name, "NoDelay")) {
                sock_opt.option = PR_SockOpt_NoDelay;
                GET_SOCKET_OPTION(self->fd, sock_opt, option);
                RETVAL = boolSV(sock_opt.value.no_delay ? TRUE : FALSE);
            }
            else if (strEQ(name, "Blocking")) {
                sock_opt.option = PR_SockOpt_Nonblocking;
                GET_SOCKET_OPTION(self->fd, sock_opt, option);
                RETVAL = boolSV(sock_opt.value.non_blocking ? FALSE : TRUE);
            }
            else {
                croak("Unknown option '%s'", option);            
            }
        }
        else if (SvIOK(option)) {
            EVALUATE_SEC_CALL(SSL_OptionGet(self->ssl_fd, SvIV(option), &on), "Failed to get option")
            RETVAL = newSViv(on);
        }
    OUTPUT:
        RETVAL
        
void
set_verify_certificate_hook(self, hook)
    Net::NSS::SSL self;
    SV * hook;
    CODE:
        if (self->verify_certificate_hook != NULL) {
            SvREFCNT_dec(self->verify_certificate_hook);
        }
        if (SvPOK(hook) && strEQ(SvPV_nolen(hook), "built-in-ignore")) {
            EVALUATE_SEC_CALL(SSL_AuthCertificateHook(self->ssl_fd, verify_certificate_ignore_hook, NULL), "Failed to set auth certificate hook to ignore");
        }
        else if (SvTRUE(hook)) {
            if (self->verify_certificate_hook != NULL) {
                EVALUATE_SEC_CALL(SSL_AuthCertificateHook(self->ssl_fd, verify_certificate_hook, self), "Failed to set auth certificate hook");
            }
            self->verify_certificate_hook = SvREFCNT_inc(hook);
        }
        else {
            EVALUATE_SEC_CALL(SSL_AuthCertificateHook(self->ssl_fd, SSL_AuthCertificate, NULL), "Failed to set default auth certificate hook");
        }

void
set_bad_certificate_hook(self, hook)
    Net::NSS::SSL self;
    SV * hook;
    CODE:
        if (self->bad_certificate_hook != NULL) {
            SvREFCNT_dec(self->bad_certificate_hook);
        }
        if (SvTRUE(hook)) {
            if (self->bad_certificate_hook != NULL) {
                EVALUATE_SEC_CALL(SSL_BadCertHook(self->ssl_fd, bad_certificate_hook, self), "Failed to set bad certificate hook");
            }
            if (self->bad_certificate_hook == NULL) {
                self->bad_certificate_hook = newSVsv(hook);
            }
            else {
                sv_setsv(self->bad_certificate_hook, hook);