static SCM make_doc(SCM ingredients, SCM recipe) {
MAKE_NODE *node;
FILE_NODE *fnode;
SCM smob, cursor;
if (scm_is_symbol(ingredients)) {
if (ingredients == file_sym) {
node = make_node(TYPE_FILE);
node->filepath = scm_to_locale_string(recipe);
node->dirty = 1;
fnode = (FILE_NODE *)malloc(sizeof(FILE_NODE));
fnode->node = node;
fnode->mtime = 0;
fnode->next = file_nodes;
file_nodes = fnode;
}
else {
node = make_node(TYPE_DATUM);
node->dirty = 0;
node->payload = recipe;
}
SCM_RETURN_NEWSMOB(make_node_tag, node);
}
node = make_node(TYPE_CHAIN);
node->dirty = 1;
node->callback = recipe;
SCM_NEWSMOB(smob, make_node_tag, node);
cursor = ingredients;
while (cursor != SCM_EOL) {
add_ascendant(SCM_CAR(cursor), smob);
cursor = SCM_CDR(cursor);
}
scm_remember_upto_here_2(ingredients, recipe);
scm_remember_upto_here_2(smob, cursor);
return smob;
}
SCM
mu_scm_mailbox_create0 (mu_mailbox_t mbox, int noclose)
{
struct mu_mailbox *mum;
mum = scm_gc_malloc (sizeof (struct mu_mailbox), "mailbox");
mum->mbox = mbox;
mum->itr = NULL;
mum->noclose = noclose;
SCM_RETURN_NEWSMOB (mailbox_tag, mum);
}
SCM
mu_guile_msg_to_scm (MuMsg *msg)
{
MuMsgWrapper *msgwrap;
g_return_val_if_fail (msg, SCM_UNDEFINED);
msgwrap = scm_gc_malloc (sizeof (MuMsgWrapper), "msg");
msgwrap->_msg = msg;
msgwrap->_unrefme = FALSE;
SCM_RETURN_NEWSMOB (MSG_TAG, msgwrap);
}
SCM
mu_scm_body_create (SCM msg, mu_body_t body)
{
struct mu_body *mbp;
mbp = scm_gc_malloc (sizeof (struct mu_body), "body");
mbp->msg = msg;
mbp->body = body;
mbp->stream = NULL;
mbp->offset = 0;
mbp->buffer = NULL;
mbp->bufsize = 0;
SCM_RETURN_NEWSMOB (body_tag, mbp);
}
static SCM squeeze(SCM source, int method) {
z_stream strm;
DEFLATE_BLOB *blob;
int ret;
size_t inlen, outlen;
char *inbuf, *outbuf;
strm.zalloc = Z_NULL;
strm.zfree = Z_NULL;
strm.opaque = Z_NULL;
if (method == SQUEEZE_GZIP) {
ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY);
}
else {
ret = deflateInit(&strm, Z_DEFAULT_COMPRESSION);
}
if (ret != Z_OK) {
log_msg("zlib: deflate init failed\n");
return SCM_BOOL_F;
}
inbuf = scm_to_utf8_stringn(source, &inlen);
strm.total_in = strm.avail_in = inlen;
strm.next_in = (unsigned char*)inbuf;
outlen = deflateBound(&strm, inlen);
outbuf = (char *)malloc(outlen);
strm.total_out = 0;
strm.avail_out = outlen;
strm.next_out = (unsigned char *)outbuf;
ret = deflate(&strm, Z_FINISH);
free(inbuf);
blob = (DEFLATE_BLOB *)scm_gc_malloc(sizeof(DEFLATE_BLOB) +
strm.total_out, "gzip-blob");
blob->zip_len = strm.total_out;
blob->orig_len = inlen;
log_msg("compress %s %d -> %d\n",
(method == SQUEEZE_GZIP ? "gzip" : "deflate"),
blob->orig_len, blob->zip_len);
blob->method = method;
ret = deflateEnd(&strm);
if (ret != Z_OK) printf("deflateEnd: %d\n", ret);
memcpy(blob->payload, outbuf, blob->zip_len);
free(outbuf);
SCM_RETURN_NEWSMOB(deflate_tag, blob);
}
static SCM scm_rag_select_event_set2scm(scm_rag_epoll_event_set *event_set,
ses_type type)
{
SCM_RETURN_NEWSMOB(scm_rag_select_event_set_tag ,event_set);
}
SCM
guile_sock_connect (SCM host, SCM proto, SCM port)
{
svz_socket_t *sock;
uint32_t xhost;
uint16_t xport = 0;
uint16_t p;
int xproto;
char *str;
struct sockaddr_in addr;
SCM ret = SCM_BOOL_F;
SCM_ASSERT (scm_is_integer (host) || scm_is_string (host), host, SCM_ARG1,
FUNC_NAME);
SCM_ASSERT (scm_is_integer (proto), proto, SCM_ARG2, FUNC_NAME);
/* Extract host to connect to. */
if (scm_is_integer (host))
xhost = htonl (scm_to_uint32 (host));
else
{
str = guile_to_string (host);
if (svz_inet_aton (str, &addr) == -1)
{
if (guile_resolve (str, &xhost) == -1)
{
guile_error ("%s: IP in dotted decimals or hostname expected",
FUNC_NAME);
free (str);
return ret;
}
}
else
xhost = addr.sin_addr.s_addr;
free (str);
}
/* Extract protocol to use. */
xproto = scm_to_int (proto);
/* Find out about given port. */
if (!SCM_UNBNDP (port))
{
SCM_ASSERT (scm_is_integer (port), port, SCM_ARG3, FUNC_NAME);
p = scm_to_uint16 (port);
xport = htons (p);
}
/* Depending on the requested protocol; create different kinds of
socket structures. */
switch (xproto)
{
case PROTO_TCP:
sock = svz_tcp_connect (xhost, xport);
break;
case PROTO_UDP:
sock = svz_udp_connect (xhost, xport);
break;
case PROTO_ICMP:
sock = svz_icmp_connect (xhost, xport, ICMP_SERVEEZ);
break;
default:
scm_out_of_range (FUNC_NAME, proto);
}
if (sock == NULL)
return ret;
sock->disconnected_socket = guile_func_disconnected_socket;
SCM_RETURN_NEWSMOB (guile_svz_socket_tag, sock);
}
SCM scm_rag_epoll_event_set2scm(scm_rag_epoll_event_set *ees)
{
SCM_RETURN_NEWSMOB(rag_epoll_event_set_tag ,ees);
}
SCM scm_return_newsmob(scm_t_bits tag, void* data) {
SCM_RETURN_NEWSMOB (tag, data);
}
