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; }