static void termios_set_cc (void)
{
SLang_Array_Type *at;
SLang_MMT_Type *mmt;
struct termios *s;
unsigned char *at_data;
int i;
if (-1 == SLang_pop_array_of_type (&at, SLANG_UCHAR_TYPE))
return;
if (NULL == (mmt = SLang_pop_mmt (Termios_Type_Id)))
goto free_and_return;
s = (struct termios *) SLang_object_from_mmt (mmt);
if (at->num_elements != NCCS)
{
SLang_verror (SL_TYPE_MISMATCH,
"Expecting UChar_Type[%d]", NCCS);
goto free_and_return;
}
at_data = (unsigned char *) at->data;
for (i = 0; i < NCCS; i++)
s->c_cc[i] = at_data[i];
/* drop */
free_and_return:
SLang_free_array (at);
SLang_free_mmt (mmt);
}
static void posix_fdopen (SLFile_FD_Type *f, char *mode)
{
Stdio_MMT_List_Type *elem;
if (NULL == (elem = alloc_stdio_list_elem ()))
return;
if (-1 == _pSLstdio_fdopen (f->name, f->fd, mode))
{
SLfree ((char *)elem);
return;
}
if (NULL == (elem->stdio_mmt = SLang_pop_mmt (SLANG_FILE_PTR_TYPE)))
{
SLfree ((char *) elem);
return;
}
if (-1 == SLang_push_mmt (elem->stdio_mmt))
{
SLfree ((char *) elem);
return;
}
elem->next = f->stdio_mmt_list;
f->stdio_mmt_list = elem;
}
static void sl_ssl_read(void){
SLssl_Type *ssl;
SLang_MMT_Type *sslmmt;
SLang_Ref_Type *buff;
void *ibuff;
SLang_BString_Type *data;
int r, rlen;
if (SLang_pop_integer(&rlen)==-1 ||
SLang_pop_ref(&buff)==-1 ||
NULL==(sslmmt=SLang_pop_mmt(SLssl_Type_Id)))
return;
ssl=(SLssl_Type *)SLang_object_from_mmt(sslmmt);
ibuff=(void *)malloc(rlen);
r=SSL_read((SSL *)ssl->ssl,ibuff,rlen);
data=SLbstring_create((unsigned char *)ibuff,r);
SLang_assign_to_ref(buff, SLANG_BSTRING_TYPE, (VOID_STAR)&data);
if (r>=0)
SLang_push_integer(r);
else
SLang_verror(r,"SSL read returned error code %d",
SSL_get_error((SSL *)ssl->ssl,r));
SLang_free_ref(buff);
}
static SLang_Foreach_Context_Type *
cl_foreach_open (SLtype type, unsigned int num)
{
SLang_Foreach_Context_Type *c;
unsigned char flags;
SLang_MMT_Type *mmt;
(void) type;
if (NULL == (mmt = SLang_pop_mmt (SLANG_ASSOC_TYPE)))
return NULL;
flags = 0;
while (num--)
{
char *s;
if (-1 == SLang_pop_slstring (&s))
{
SLang_free_mmt (mmt);
return NULL;
}
if (0 == strcmp (s, "keys"))
flags |= CTX_WRITE_KEYS;
else if (0 == strcmp (s, "values"))
flags |= CTX_WRITE_VALUES;
else
{
_pSLang_verror (SL_NOT_IMPLEMENTED,
"using '%s' not supported by SLassoc_Type",
s);
_pSLang_free_slstring (s);
SLang_free_mmt (mmt);
return NULL;
}
_pSLang_free_slstring (s);
}
if (NULL == (c = (SLang_Foreach_Context_Type *) SLmalloc (sizeof (SLang_Foreach_Context_Type))))
{
SLang_free_mmt (mmt);
return NULL;
}
memset ((char *) c, 0, sizeof (SLang_Foreach_Context_Type));
if (flags == 0) flags = CTX_WRITE_VALUES|CTX_WRITE_KEYS;
c->flags = flags;
c->mmt = mmt;
c->a = (SLang_Assoc_Array_Type *) SLang_object_from_mmt (mmt);
#if SLANG_OPTIMIZE_FOR_SPEED
c->is_scalar = (SLANG_CLASS_TYPE_SCALAR == _pSLang_get_class_type (c->a->type));
#endif
return c;
}
static void test_pop_mmt (void)
{
SLang_MMT_Type *mmt;
if (NULL == (mmt = SLang_pop_mmt (SLang_peek_at_stack ())))
return;
if (-1 == SLang_push_mmt (mmt))
SLang_free_mmt (mmt);
}
static CSV_Type *pop_csv_type (SLang_MMT_Type **mmtp)
{
SLang_MMT_Type *mmt;
if (NULL == (mmt = SLang_pop_mmt (CSV_Type_Id)))
{
*mmtp = NULL;
return NULL;
}
*mmtp = mmt;
return (CSV_Type *)SLang_object_from_mmt (mmt);
}
static SLang_MMT_Type *pop_sri_type (Slsh_Readline_Type **srip)
{
SLang_MMT_Type *mmt;
if (NULL == (mmt = SLang_pop_mmt (Rline_Type_Id)))
return NULL;
if (NULL == (*srip = (Slsh_Readline_Type *)SLang_object_from_mmt (mmt)))
{
SLang_free_mmt (mmt);
return NULL;
}
return mmt;
}
static SLang_MMT_Type *pop_rli_type (SLang_RLine_Info_Type **rlip)
{
SLang_MMT_Type *mmt;
if (NULL == (mmt = SLang_pop_mmt (Rline_Type_Id)))
return NULL;
if (NULL == (*rlip = (SLang_RLine_Info_Type *)SLang_object_from_mmt (mmt)))
{
SLang_free_mmt (mmt);
return NULL;
}
return mmt;
}
static void sl_ssl_verify(void){
SLssl_Type *ssl;
SLang_MMT_Type *sslmmt;
X509 *cert;
if (NULL==(sslmmt=SLang_pop_mmt(SLssl_Type_Id)))
return;
ssl=(SLssl_Type *)SLang_object_from_mmt(sslmmt);
cert=SSL_get_peer_certificate((SSL *)ssl->ssl);
if (cert==NULL)
SLang_push_integer(-1);
else
SLang_push_integer(SSL_get_verify_result((SSL *)ssl->ssl));
X509_free(cert);
}
static void sl_ssl_handshake (void){
SLssl_Type *ssl;
SLang_MMT_Type *sslmmt;
int r;
if (NULL==(sslmmt=SLang_pop_mmt(SLssl_Type_Id)))
return;
ssl=(SLssl_Type *)SLang_object_from_mmt(sslmmt);
if (ssl->is_server==1)
r=SSL_accept((SSL *)ssl->ssl);
else
r=SSL_connect((SSL *)ssl->ssl);
if (r==1)
SLang_push_integer(r);
else
SLang_verror(r,"SSL handshake returned %d (error code %d)",r,
SSL_get_error((SSL *)ssl->ssl,r));
}
static void sl_ssl_connect (void){
int fd;
SLFile_FD_Type *slfd;
SLsslctx_Type *ctx;
SLssl_Type *slssl;
SSL *ssl;
SLang_MMT_Type *sslmmt;
SLang_MMT_Type *sslmmto;
if (SLfile_pop_fd(&slfd) == -1)
return;
if (NULL==(sslmmt=SLang_pop_mmt(SLsslctx_Type_Id)))
return;
SLfile_get_fd(slfd,&fd);
SLfile_free_fd(slfd);
ctx = (SLsslctx_Type *)SLang_object_from_mmt(sslmmt);
// create the ssl object
ssl = SSL_new((SSL_CTX *)ctx->ctx);
// set the file descriptor for input/output
if (0==SSL_set_fd(ssl,fd)){
return;
}
// fprintf(stderr,"Set client socket fd to %d\n",fd);
slssl = (SLssl_Type *)malloc(sizeof(SLssl_Type));
slssl->ssl = (void *) ssl;
slssl->is_server = ctx->is_server;
sslmmt = SLang_create_mmt(SLssl_Type_Id, (VOID_STAR) slssl);
if (0==SLang_push_mmt(sslmmt))
return;
SLang_free_mmt(sslmmt);
}
static void sl_ssl_get_cert(void){
SLssl_Type *ssl;
SLang_MMT_Type *sslmmt;
STACK_OF(X509) *cert;
unsigned char **buf;
SLang_BString_Type **certout;
SLang_Array_Type *arr;
SLindex_Type nelem;
int len,i;
if (NULL==(sslmmt=SLang_pop_mmt(SLssl_Type_Id)))
return;
ssl=(SLssl_Type *)SLang_object_from_mmt(sslmmt);
cert=SSL_get_peer_cert_chain((SSL *)ssl->ssl);
if (cert==NULL)
return NULL;
nelem=(SLindex_Type)sk_X509_num(cert);
// now we have chain of certs, create array of pointers and the
// array to hold them
buf = (unsigned char **)malloc(nelem*sizeof(unsigned char *));
arr = SLang_create_array(SLANG_BSTRING_TYPE,0,NULL,&nelem,1);
// array data structure is of bstring type
certout = (SLang_BString_Type **)arr->data;
for (i=0;i<nelem;i++){
buf[i] = NULL;
len = i2d_X509(sk_X509_value(cert,i), &(buf[i]));
certout[i] = SLbstring_create(buf[i],len);
}
SLang_push_array(arr,1);
// free the X509 stack
sk_X509_pop_free(cert,X509_free);
}
static void sl_ssl_write(void){
SLssl_Type *ssl;
SLang_MMT_Type *sslmmt;
SLang_BString_Type *data;
int r, dlen;
if (SLang_pop_bstring(&data)==-1 ||
NULL==(sslmmt=SLang_pop_mmt(SLssl_Type_Id)))
return;
ssl=(SLssl_Type *)SLang_object_from_mmt(sslmmt);
const void *idata = SLbstring_get_pointer(data,&dlen);
r=SSL_write((SSL *)ssl->ssl,idata,dlen);
if (r>=0)
SLang_push_integer(r);
else
SLang_verror(r,"SSL write returned error code %d",
SSL_get_error((SSL *)ssl->ssl,r));
SLbstring_free(data);
}
/* Usage: onig_search (o, str [start, end] [,option]) */
static int do_onig_search (void)
{
int start_pos = 0, end_pos = -1;
char *str, *str_end;
SLang_BString_Type *bstr = NULL;
Onig_Type *o;
SLang_MMT_Type *mmt;
int status = -1;
OnigOptionType option = ONIG_OPTION_NONE;
switch (SLang_Num_Function_Args)
{
default:
SLang_verror (SL_Usage_Error, "Usage: n = onig_search (compiled_pattern, str [,start_ofs, end_ofs] [,option])");
return -1;
case 5:
if (-1 == pop_onig_option (&option))
return -1;
/* drop */
case 4:
if (-1 == SLang_pop_int (&end_pos))
return -1;
if (-1 == SLang_pop_int (&start_pos))
return -1;
break;
case 3:
if (-1 == pop_onig_option (&option))
return -1;
break;
case 2:
break;
}
switch(SLang_peek_at_stack())
{
case SLANG_STRING_TYPE:
if (-1 == SLang_pop_slstring (&str))
return -1;
str_end = str + strlen (str);
break;
case SLANG_BSTRING_TYPE:
default:
{
unsigned int len;
if (-1 == SLang_pop_bstring(&bstr))
return -1;
str = (char *)SLbstring_get_pointer(bstr, &len);
if (str == NULL)
{
SLbstring_free (bstr);
return -1;
}
str_end = str + len;
}
break;
}
if (end_pos < 0)
end_pos = (int) (str_end - str);
if (NULL == (mmt = SLang_pop_mmt (Onig_Type_Id)))
goto free_and_return;
o = (Onig_Type *)SLang_object_from_mmt (mmt);
status = do_onig_search_internal (o, option, (UChar *)str, (UChar *)str_end, start_pos, end_pos);
if (status >= 0)
{
o->match_pos = status;
status = o->region->num_regs;
goto free_and_return;
}
o->match_pos = -1;
if (status == -1)
{ /* no match */
status = 0;
goto free_and_return;
}
/* Else an error occurred */
/* drop */
free_and_return:
SLang_free_mmt (mmt);
if (bstr != NULL)
SLbstring_free (bstr);
else
SLang_free_slstring (str);
return status;
}
