SCM scm_tls_recv_x(SCM tls_smob, SCM buf){
scm_assert_smob_type(tls_tag, tls_smob);
BIO *bio = (BIO*)SCM_SMOB_DATA(tls_smob);
size_t buflen = scm_c_bytevector_length(buf);
char *bufptr = (char*)SCM_BYTEVECTOR_CONTENTS(buf);
return scm_from_int(BIO_read(bio, bufptr, buflen));
}
SCM
yacl_scm_b64url_decode (SCM scmb64)
{
if (!scm_is_string (scmb64))
scm_throw (scm_from_locale_symbol ("BADSTR"), SCM_BOOL_T);
size_t scmb64len, outlen;
char * b64url = scm_to_utf8_stringn (scmb64, &scmb64len);
if (NULL == b64url)
scm_throw (scm_from_locale_symbol ("BADDECODE"), SCM_BOOL_T);
uint8_t *decode = yacl_b64url_decode (b64url, &outlen);
free (b64url);
if (NULL == decode)
scm_throw (scm_from_locale_symbol ("BADDECODED"), SCM_BOOL_T);
SCM b64 = scm_c_make_bytevector (outlen);
memcpy (SCM_BYTEVECTOR_CONTENTS (b64), decode, outlen);
free (decode);
return b64;
}
SCM
yacl_scm_sha256 (SCM bv)
{
int rc;
uint8_t out[YACL_SHA256_LEN] = {};
signed char* p = SCM_BYTEVECTOR_CONTENTS (bv);
size_t len = SCM_BYTEVECTOR_LENGTH (bv);
rc = yacl_sha256 (p, len, out);
SCM digest = scm_c_make_bytevector (YACL_SHA256_LEN);
memcpy (SCM_BYTEVECTOR_CONTENTS (digest), &out, YACL_SHA256_LEN);
return digest;
}
SCM
yacl_scm_p256_sign(SCM data, SCM d)
{
int rc;
uint8_t out[YACL_SHA256_LEN*2] = {};
unsigned char* data_ptr = SCM_BYTEVECTOR_CONTENTS (data);
size_t data_len = SCM_BYTEVECTOR_LENGTH (data);
unsigned char* d_ptr = SCM_BYTEVECTOR_CONTENTS (d);
size_t d_len = SCM_BYTEVECTOR_LENGTH (d);
rc = yacl_hash_ecdsa_sign(data_ptr, data_len, d_ptr, out);
SCM sig = scm_c_make_bytevector (YACL_SHA256_LEN*2);
memcpy (SCM_BYTEVECTOR_CONTENTS (sig), &out, YACL_SHA256_LEN*2);
return sig;
}
SCM
yacl_scm_hexdump (SCM bv)
{
int rc;
unsigned char* data_ptr = SCM_BYTEVECTOR_CONTENTS (bv);
size_t data_len = SCM_BYTEVECTOR_LENGTH (bv);
yacl_hexdump (data_ptr, data_len);
return SCM_BOOL_T;
}
void test_free_handle_bytevector_postfields(void)
{
extern SCM cl_CURLOPT_POSTFIELDS;
SCM handle = cl_easy_init();
SCM bv = scm_c_make_bytevector (26);
for (int i = 0; i <= 25; i ++)
SCM_BYTEVECTOR_CONTENTS(bv)[i] = i + 'a';
SCM ret = cl_easy_setopt(handle, scm_variable_ref(cl_CURLOPT_POSTFIELDS), bv, SCM_BOOL_F);
gc_free_handle(handle);
}
SCM
yacl_scm_p256_verify(SCM data, SCM q, SCM sig)
{
int rc;
unsigned char* data_ptr = SCM_BYTEVECTOR_CONTENTS (data);
size_t data_len = SCM_BYTEVECTOR_LENGTH (data);
unsigned char* q_ptr = SCM_BYTEVECTOR_CONTENTS (q);
size_t q_len = SCM_BYTEVECTOR_LENGTH (q);
unsigned char* sig_ptr = SCM_BYTEVECTOR_CONTENTS (sig);
size_t sig_len = SCM_BYTEVECTOR_LENGTH (sig);
rc = yacl_hash_verify(data_ptr, data_len, q_ptr, sig_ptr);
if (0 == rc)
return SCM_BOOL_T;
else
return SCM_BOOL_F;
}
static size_t
write_to_channel_port (SCM channel, SCM src, size_t start, size_t count)
#define FUNC_NAME "write_to_channel_port"
{
char *data = (char *) SCM_BYTEVECTOR_CONTENTS (src) + start;
struct channel_data *channel_data = _scm_to_channel_data (channel);
int res = ssh_channel_write (channel_data->ssh_channel, data, count);
if (res == SSH_ERROR)
{
ssh_session session = ssh_channel_get_session (channel_data->ssh_channel);
guile_ssh_session_error1 (FUNC_NAME, session, channel);
}
assert (res >= 0);
return res;
}
SCM
yacl_scm_get_random (SCM len)
{
if (!scm_is_integer (len))
goto EXCEPTION;
size_t rndlen = scm_to_size_t (len);
SCM rnd = scm_c_make_bytevector (rndlen);
int rc = yacl_get_random(SCM_BYTEVECTOR_CONTENTS (rnd), rndlen);
if (rc)
goto EXCEPTION;
else
goto OUT;
EXCEPTION:
scm_throw (scm_from_locale_symbol ("BADRANDOM"), SCM_BOOL_T);
OUT:
return rnd;
}
SCM
yacl_scm_b64url_encode (SCM bv)
{
if (!scm_is_bytevector (bv))
scm_throw (scm_from_locale_symbol ("BADBV"), SCM_BOOL_T);
uint8_t *bv_ptr;
size_t bv_len;
bv_ptr = SCM_BYTEVECTOR_CONTENTS (bv);
bv_len = SCM_BYTEVECTOR_LENGTH (bv);
char *b64url = yacl_b64url_encode (bv_ptr, bv_len);
if (NULL == b64url)
scm_throw (scm_from_locale_symbol ("BADENCODE"), SCM_BOOL_T);
SCM out = scm_from_utf8_string (b64url);
free (b64url);
return out;
}
/* Return a new string port with MODES. If STR is #f, a new backing
buffer is allocated; otherwise STR must be a string and a copy of it
serves as the buffer for the new port. */
SCM
scm_mkstrport (SCM pos, SCM str, long modes, const char *caller)
{
SCM z, buf;
scm_t_port *pt;
const char *encoding;
size_t read_buf_size, str_len, c_pos;
char *c_buf;
if (!((modes & SCM_WRTNG) || (modes & SCM_RDNG)))
scm_misc_error ("scm_mkstrport", "port must read or write", SCM_EOL);
encoding = scm_i_default_port_encoding ();
if (scm_is_false (str))
{
/* Allocate a new buffer to write to. */
str_len = INITIAL_BUFFER_SIZE;
buf = scm_c_make_bytevector (str_len);
c_buf = (char *) SCM_BYTEVECTOR_CONTENTS (buf);
/* Reset `read_buf_size'. It will contain the actual number of
bytes written to the port. */
read_buf_size = 0;
c_pos = 0;
}
else
{
/* STR is a string. */
char *copy;
SCM_ASSERT (scm_is_string (str), str, SCM_ARG1, caller);
/* Create a copy of STR in ENCODING. */
copy = scm_to_stringn (str, &str_len, encoding,
SCM_FAILED_CONVERSION_ERROR);
buf = scm_c_make_bytevector (str_len);
c_buf = (char *) SCM_BYTEVECTOR_CONTENTS (buf);
memcpy (c_buf, copy, str_len);
free (copy);
c_pos = scm_to_unsigned_integer (pos, 0, str_len);
read_buf_size = str_len;
}
z = scm_c_make_port_with_encoding (scm_tc16_strport, modes,
encoding,
scm_i_default_port_conversion_handler (),
(scm_t_bits)buf);
pt = SCM_PTAB_ENTRY (z);
pt->write_buf = pt->read_buf = (unsigned char *) c_buf;
pt->read_pos = pt->write_pos = pt->read_buf + c_pos;
pt->read_buf_size = read_buf_size;
pt->write_buf_size = str_len;
pt->write_end = pt->read_end = pt->read_buf + pt->read_buf_size;
pt->rw_random = 1;
return z;
}
