void buflongalign(caryll_Buffer *buf) {
size_t cp = buf->cursor;
bufseek(buf, buflen(buf));
if (buflen(buf) % 4 == 1) {
bufwrite8(buf, 0);
bufwrite8(buf, 0);
bufwrite8(buf, 0);
} else if (buflen(buf) % 4 == 2) {
bufwrite8(buf, 0);
bufwrite8(buf, 0);
} else if (buflen(buf) % 4 == 3) {
bufwrite8(buf, 0);
}
bufseek(buf, cp);
}
void bufwrite_buf(caryll_Buffer *buf, caryll_Buffer *that) {
if (!that || !that->data) return;
size_t len = buflen(that);
bufbeforewrite(buf, len);
memcpy(buf->data + buf->cursor, that->data, len);
buf->cursor += len;
}
void process_request(int fd) {
if (server.clients[fd] == NULL) {
return;
}
buffer* in_buf = server.clients[fd] -> in_buf;
buffer* out_buf = server.clients[fd] -> out_buf;
int i, len = buflen(in_buf);
int req_len_end_pos = -1;
for (i = 0; i < len; i++) {
if (in_buf -> buf[i] == SEPARATOR) {
req_len_end_pos = i;
break;
}
}
if (req_len_end_pos == -1) {
return;
}
int req_len = -1;
char tmp;
sscanf(in_buf -> buf, "%d%c", &req_len, &tmp);
if (len - req_len_end_pos - 1 < req_len) {
return;
}
char op[100], *rest, tmp_buf[1024];
memcpy(tmp_buf, in_buf -> buf + req_len_end_pos + 1, req_len * sizeof(char));
tmp_buf[req_len] = '\0';
sscanf(tmp_buf, "%s", op);
rest = tmp_buf + strlen(op) + 1;
if (strcmp(op, "GET") == 0) {
void* res = get_from_map(server.db, rest);
if (res) {
append_to_buffer(out_buf, (char*) res);
} else {
append_to_buffer(out_buf, "");
}
} else if (strcmp(op, "SET") == 0) {
char key[100], value[100];
sscanf(rest, "%s %s", key, value);
free(remove_from_map(server.db, key));
char* kivi_obj = malloc((strlen(value) + 1) * sizeof(char));
memcpy(kivi_obj, value, (strlen(value) + 1) * sizeof(char));
put_in_map(server.db, key, kivi_obj);
append_to_buffer(out_buf, "OK");
} else if (strcmp(op, "DEL") == 0) {
free(remove_from_map(server.db, rest));
append_to_buffer(out_buf, "OK");
}
memcpy(in_buf -> buf, in_buf -> buf + req_len_end_pos + 1 + req_len, (len - req_len_end_pos - 1 - req_len) * sizeof(char));
in_buf -> end_pos -= req_len_end_pos + 1 + req_len;
in_buf -> buf[in_buf -> end_pos] = '\0';
}
int socket_writer(event_loop* el, int fd, kivi_client* client) {
buffer* out_buf = client -> out_buf;
if (buflen(out_buf)) {
int sz = send(fd, &(out_buf -> buf[out_buf -> start_pos]), buflen(out_buf), 0);
if (sz == -1) {
log_warn("couldn't send message to %d", fd);
return FAILED;
} else {
if (sz) {
memcpy(out_buf -> buf, out_buf -> buf + out_buf -> start_pos + sz, (buflen(out_buf) - sz) * sizeof(char));
out_buf -> start_pos = 0;
out_buf -> end_pos -= sz;
out_buf -> buf[out_buf -> end_pos] = '\0';
}
return OK;
}
} else {
return OK;
}
}
void
writeNode(xercesc::DOMNode& node,
std::string& text,
const WriteParameters& params)
{
Platform xmlplat;
xercesc::MemBufFormatTarget target(4096);
write_target(node, target, params);
const XMLByte *buf(target.getRawBuffer());
XMLSize_t buflen(target.getLen());
text.assign(reinterpret_cast<const char *>(buf),
reinterpret_cast<const char *>(buf) + buflen);
}
static int
ah_put(ostream &os, AHRecord const &rec0)
{
// write header+data to an ostream
AHRecord rec(rec0); // XXX for const'ness
// write header *********************************
int status=AH_SUCCESS, ndata, dtype;
{
char hbuf[HEADER_SIZE];
XDR xdrs;
xdrmem_create(&xdrs, hbuf, HEADER_SIZE, XDR_ENCODE);
if ( ! xdr_Header(&xdrs, &rec, ndata, dtype)) // sets ndata, dtype
status = AH_ERROR;
if (status != AH_SUCCESS)
return AH_ERROR;
os.write(hbuf, HEADER_SIZE);
if (os.fail())
return AH_ERROR;
xdr_destroy(&xdrs);
}
// write data samples ***************************
XDR xdrs;
int bufsize = buflen(ndata, dtype);
// write data to an ostream
vector<char> dbuf(bufsize+100);
char *buf = &dbuf[0];
xdrmem_create(&xdrs, buf, bufsize, XDR_ENCODE);
int n = ndata;
switch (dtype) {
case AH_DATATYPE_FLOAT:
{
# ifdef IEEE_INTEL
char *b2 = (char*) xdrs.x_private;
# endif
Array *arr = rec.data();
if (arr==0)
cerr << "THIS MUST NEVER HAPPEN: arr==0\n";
float *f = (float*)(arr->data());
# ifdef IEEE_SPARC
assert(sizeof(float)==4);
memcpy((void*) xdrs.x_private, (void*)f, n*sizeof(float));
# else
while (n--) {
# ifdef IEEE_INTEL
char *b1 = (char*)(++f);
*(b2++) = *(--b1);
*(b2++) = *(--b1);
*(b2++) = *(--b1);
*(b2++) = *(--b1);
# else
if ( ! xdr_float(&xdrs, f++)) {
cerr << "error while reading data" << endl;
status = AH_ERROR;
break;
}
# endif
}
# endif
}
break;
case AH_DATATYPE_COMPLEX:
/*
{
float re, im;
Complex *c = (Complex*) rec.xdata;
for (i=0; i<n; i++) {
re = real(c[i]);
im = imag(c[i]);
if ( ! xdr_float(&xdrs, &re) ||
! xdr_float(&xdrs, &im)) {
ah_error(ahERR_IO_WR, "error while writing data");
status = AH_ERROR;
break;
}
}
}
*/
break;
default:
cerr << "ah_error_illegal_data_type YY" << endl;
break;
}
xdr_destroy(&xdrs);
os.write(buf, bufsize);
if (os.fail())
status = AH_ERROR;
return status;
}
static int
ah_get(istream &is, AHRecord &rec)
{
// read header+data from an istream
int ndata, dtype;
// read header *********************************
char hbuf[HEADER_SIZE];
XDR xdrs;
// read a header from an istream
is.read(hbuf, HEADER_SIZE);
if (is.eof()) {
// no bytes read -> proper EOF
// otherwise -> unexpected EOF
return is.gcount()==0 ? AH_SUCCESS : AH_ERROR;
}
if (is.fail()) {
cerr << "failed to read header" << endl;
return AH_ERROR;
}
xdrmem_create(&xdrs, hbuf, (unsigned int) HEADER_SIZE, XDR_DECODE);
int status = AH_SUCCESS;
// read a header from an XDR stream
if ( ! xdr_Header(&xdrs, &rec, ndata, dtype))
status = AH_ERROR;
// check data type -> XXX do this inside xdr_Header
// if ( ! is_valid_data_type(rec->type))
// status = AH_ERROR;
if (status == AH_SUCCESS && is.eof()) // XXX XXX XXX XXX XXX XXX XXX
return AH_SUCCESS; // proper EOF
// read data samples ***************************
size_t bufsize = buflen(ndata, dtype);
vector<char> dbuf(bufsize);
char *buf = &dbuf[0];
is.read(buf, bufsize);
// While reading data we shall never reach EOF
if (is.eof())
return AH_ERROR; // unexpected EOF
if (is.fail())
return AH_ERROR; // <- obsolete ???
xdrmem_create(&xdrs, buf, bufsize, XDR_DECODE);
int n = ndata;
switch (dtype) {
case AH_DATATYPE_FLOAT:
{
// allocate new data
FloatArray *arr = new FloatArray(n);
rec.setData(arr);
float *f = (float*)(arr->data());
# ifdef IEEE_INTEL
float *f0 = (float*) xdrs.x_private;
char *b2 = (char*) f;
# endif
// read data
# ifdef IEEE_SPARC
assert(sizeof(float)==4);
// copy without swapping
memcpy(f, (void*) xdrs.x_private, n*sizeof(float));
# else
while (n--)
{
# ifdef IEEE_INTEL
char *b1 = (char*)(++f0);
*(b2++) = *(--b1);
*(b2++) = *(--b1);
*(b2++) = *(--b1);
*(b2++) = *(--b1);
# else
if ( ! xdr_float(&xdrs, f++))
cerr << "error while reading data" << endl;
# endif
}
# endif
}
break;
case AH_DATATYPE_COMPLEX:
/*
{
float re, im;
// allocate new data
Complex *c = new Complex [n];
rec->xdata = (void*) c;
// read data
for (int i=0; i<n; i++, c++)
{
re = im = 0.0;
if ( ! xdr_float(&xdrs, &re) ||
! xdr_float(&xdrs, &im))
ah_error(1, "error while reading data");
*c = Complex(re, im);
}
}
*/
break;
default:
cerr << "ah_error_illegal_data_type XY" << endl;
break;
}
xdr_destroy(&xdrs);
return status;
}
