/*}}}*/
};
int
xchar_length (xchar_t ch) /*{{{*/
{
return utf8_length_tab[ch];
}/*}}}*/
int
xchar_strict_length (xchar_t ch) /*{{{*/
{
return utf8_strict_length_tab[ch];
}/*}}}*/
int
xchar_valid_position (const xchar_t *s, int length) /*{{{*/
{
# define VALID(ccc) (((ccc) & 0xc0) == 0x80)
int len, n;
if (((len = xchar_strict_length (*s)) > 0) && (length >= len))
for (n = len; n > 1; ) {
--n;
if (! VALID (*(s + n))) {
len = -1;
break;
}
}
else
len = -1;
return len;
# undef VALID
}/*}}}*/
bool_t
xchar_valid (const xchar_t *s, int length) /*{{{*/
{
int n;
while (length > 0)
if ((n = xchar_valid_position (s, length)) > 0) {
s += n;
length -= n;
} else
break;
return length == 0 ? true : false;
}/*}}}*/
const char *
xchar_to_char (const xchar_t *s) /*{{{*/
{
return (const char *) s;
}/*}}}*/
const xchar_t *
char_2_xchar (const char *s) /*{{{*/
{
return (const xchar_t *) s;
}/*}}}*/
const char *
byte_to_char (const byte_t *b) /*{{{*/
{
return (const char *) b;
}/*}}}*/
int
xstrlen (const xchar_t *s) /*{{{*/
{
int len, clen;
for (len = 0; *s; ++len) {
clen = xchar_length (*s);
while ((clen-- > 0) && *s)
++s;
}
return len;
}/*}}}*/
int
xstrcmp (const xchar_t *s1, const char *s2) /*{{{*/
{
return strcmp (xchar_to_char (s1), s2);
}/*}}}*/
int
xstrncmp (const xchar_t *s1, const char *s2, size_t n) /*{{{*/
{
return strncmp (xchar_to_char (s1), s2, n);
}/*}}}*/
bool_t
xmlbuf_equal (xmlbuf_t *b1, xmlbuf_t *b2) /*{{{*/
{
if ((! b1) && (! b2))
return true;
if (b1 && b2 && (b1 -> length == b2 -> length) &&
((! b1 -> length) || (! memcmp (b1 -> buffer, b2 -> buffer, b1 -> length))))
return true;
return false;
}/*}}}*/
char *
xmlbuf_to_string (xmlbuf_t *b) /*{{{*/
{
return buffer_copystring ((buffer_t *) b);
}/*}}}*/
long
xmlbuf_to_long (xmlbuf_t *b) /*{{{*/
{
const char *s = b ? buffer_string (b) : NULL;
return s ? strtol (s, NULL, 0) : -1;
}/*}}}*/
uvmongo_message_t *
uvmongo_message_serialize_query(uvmongo_cursor_t * cursor) {
char * data;
char * ns = buffer_string(cursor->coll->fullname);
size_t nslen = strlen(ns) + 1;
size_t bslen = bson_size(cursor->query) + bson_size(cursor->fields);
size_t msglen = 16 + 4 + nslen + 4 + 4 + bslen;
uvmongo_message_t * msg = uvmongo_message_new(msglen, 0, 0, OP_QUERY);
msg->privdata = NULL;
msg->cursor = cursor;
data = &msg->data;
data = uvmongo_message_append32(data, &cursor->flag);
data = uvmongo_message_append(data, ns, nslen);
data = uvmongo_message_append32(data, &cursor->skip);
data = uvmongo_message_append32(data, &cursor->limit);
data = uvmongo_message_append(data, cursor->query->data, bson_size(cursor->query));
if (cursor->fields) {
data = uvmongo_message_append(data, cursor->fields->data, bson_size(cursor->fields));
}
assert(data == ((char*)msg) + sizeof(uvmongo_cursor_t*)
+ sizeof(uvmongo_document_cb)
+ sizeof(uvmongo_response_cb)
+ sizeof(void*)
+ msg->header.msglen);
return msg;
}
uvmongo_message_t *
uvmongo_message_serialize_more(uvmongo_cursor_t * cursor) {
char * data;
char * ns = buffer_string(cursor->coll->fullname);
size_t nslen = strlen(ns) + 1;
size_t msglen = 16 + 4 + nslen + 4 + 8;
uvmongo_message_t * msg = uvmongo_message_new(msglen, 0, 0, OP_GET_MORE);
data = &msg->data;
data = uvmongo_message_append32(data, &ZERO);
data = uvmongo_message_append(data, ns, nslen);
data = uvmongo_message_append32(data, &cursor->limit);
data = uvmongo_message_append64(data, &cursor->id);
return msg;
}
uvmongo_message_t *
uvmongo_message_serialize_delete(buffer_t * fullname, bson * selector) {
char * data;
char * ns = buffer_string(fullname);
size_t nslen = strlen(ns) + 1;
size_t bslen = bson_size(selector);
size_t msglen = 16 + 4 + nslen + 4 + bslen;
uvmongo_message_t * msg = uvmongo_message_new(msglen, 0, 0, OP_DELETE);
data = &msg->data;
data = uvmongo_message_append32(data, &ZERO);
data = uvmongo_message_append(data, ns, nslen);
data = uvmongo_message_append32(data, &ONE);
data = uvmongo_message_append(data, selector->data, bson_size(selector));
return msg;
}
uvmongo_message_t *
uvmongo_message_serialize_insert(buffer_t * fullname, bson * obj) {
/*
* FIXME(Yorkie): support batch insert
*/
char * data;
char * ns = buffer_string(fullname);
size_t nslen = strlen(ns) + 1;
size_t bslen = bson_size(obj);
size_t msglen = 16 + 4 + nslen + bslen;
uvmongo_message_t * msg = uvmongo_message_new(msglen, 0, 0, OP_INSERT);
data = &msg->data;
data = uvmongo_message_append32(data, &ZERO);
data = uvmongo_message_append(data, ns, nslen);
data = uvmongo_message_append(data, obj->data, bslen);
data = &msg->data;
return msg;
}
uvmongo_message_t *
uvmongo_message_serialize_update(buffer_t * fullname, bson * selector,
bson * setup,
uvmongo_update_flags_t flag) {
char * data;
char * ns = buffer_string(fullname);
size_t nslen = strlen(ns) + 1;
size_t bslen = bson_size(selector) + bson_size(setup);
size_t msglen = 16 + 4 + nslen + 4 + bslen;
uvmongo_message_t * msg = uvmongo_message_new(msglen, 0, 0, OP_UPDATE);
data = &msg->data;
data = uvmongo_message_append32(data, &ZERO);
data = uvmongo_message_append(data, ns, nslen);
data = uvmongo_message_append32(data, &flag);
data = uvmongo_message_append(data, selector->data, bson_size(selector));
data = uvmongo_message_append(data, setup->data, bson_size(setup));
return msg;
}
void
net_read(uv_stream_t *handle, ssize_t nread, const uv_buf_t buf) {
net_t * net = (net_t *) handle->data;
err_t err;
if (nread < 0) {
err = uv_last_error(net->loop);
if (net->error_cb) {
net->error_cb(net, err, (char *) uv_strerror(err));
} else {
printf("error(%s:%d) %s", net->hostname, net->port, (char *) uv_strerror(err));
net_free(net);
}
return;
}
/*
* BIO Return rule:
* All these functions return either the amount of data successfully
* read or written (if the return value is positive) or that no data
* was successfully read or written if the result is 0 or -1. If the
* return value is -2 then the operation is not implemented in the specific BIO type.
*/
if (net->use_ssl) {
net->tls->data = malloc(1);
tls_bio_write(net->tls, buf.base, nread);
free(buf.base);
int read = 0;
int stat = tls_read(net->tls);
if (stat == 1) {
/*
* continue: Say hello
*/
do {
read = tls_bio_read(net->tls, 0);
if (read > 0) {
uv_write_t req;
uv_buf_t uvbuf = uv_buf_init(net->tls->buf, read);
uv_write(&req, (uv_stream_t*)net->handle, &uvbuf, 1, NULL);
}
} while (read > 0);
} else if (stat == 0) {
/*
* SSL Connection is created
* Here need to call user-land callback
*/
uv_read_stop((uv_stream_t*)net->handle);
if (net->read_cb != NULL) {
net->read_cb(net, buffer_length(net->tls->buffer),
buffer_string(net->tls->buffer));
}
} else if (stat == -1) {
/*
* Just connection in SSL
* call `conn_cb`, the ssl connection has been
* established in user-land.
*/
if (net->conn_cb != NULL) {
net->conn_cb(net);
}
} else {
/*
* TODO(Yorkie): HOWTO
*/
}
return;
}
/*
* TCP Part, no SSL, just proxy of uv.
*/
uv_read_stop(handle);
buf.base[nread] = 0;
if (net->read_cb != NULL) {
net->read_cb(net, nread, buf.base);
}
}
