本文整理汇总了C++中buf_write函数的典型用法代码示例。如果您正苦于以下问题：C++ buf_write函数的具体用法？C++ buf_write怎么用？C++ buf_write使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了buf_write函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: write_trigger_poll
void write_trigger_poll(rpc_comm_t *comm,
poll_job_t* pjob,
buf_t *buf,
msgid_t msgid,
uint8_t *data,
size_t sz_data) {
apr_thread_mutex_lock(comm->mx);
// apr_atomic_add32(&sz_data_tosend_, sizeof(funid_t) + sz_buf + sizeof(size_t));
// apr_atomic_inc32(&n_data_sent_);
// realloc the write buf if not enough.
buf_readjust(buf, sz_data + SZ_SZMSG + SZ_MSGID);
// copy memory
LOG_TRACE("add message to sending buffer, message size: %d, message type: %x", (int32_t)sz_data, (int32_t)msgid);
// LOG_TRACE("size in buf:%llx, original size:%llx",
// *(ctx->buf_send.buf + ctx->buf_send.offset_end), sz_buf + sizeof(funid_t));
size_t n = SZ_SZMSG;
SAFE_ASSERT(buf_write(buf, (uint8_t*)&sz_data, n) == n);
SAFE_ASSERT(msgid != 0); // message id cannot be zero
n = SZ_MSGID;
SAFE_ASSERT(buf_write(buf, (uint8_t*)&msgid, n) == n);
n = sz_data;
SAFE_ASSERT(buf_write(buf, (uint8_t*)data, n) == n);
// change poll type
poll_mgr_update_job(pjob->mgr, pjob, APR_POLLIN | APR_POLLOUT);
apr_thread_mutex_unlock(comm->mx);
}示例2: wsgi_getheaders
static size_t
wsgi_getheaders(Request* request, PyObject* buf)
{
char* bufp = PyString_AS_STRING(buf);
Py_ssize_t i;
#define buf_write(src, len) \
do { \
size_t n = len; \
const char* s = src; \
while(n--) *bufp++ = *s++; \
} while(0)
#define buf_write2(src) buf_write(src, strlen(src))
buf_write2("HTTP/1.1 ");
buf_write(PyString_AS_STRING(request->status),
PyString_GET_SIZE(request->status));
for(i=0; i<PyList_GET_SIZE(request->headers); ++i) {
PyObject *tuple = PyList_GET_ITEM(request->headers, i);
PyObject *field = PyTuple_GET_ITEM(tuple, 0),
*value = PyTuple_GET_ITEM(tuple, 1);
buf_write2("\r\n");
buf_write(PyString_AS_STRING(field), PyString_GET_SIZE(field));
buf_write2(": ");
buf_write(PyString_AS_STRING(value), PyString_GET_SIZE(value));
}
if(request->state.chunked_response)
buf_write2("\r\nTransfer-Encoding: chunked");
buf_write2("\r\n\r\n");
return bufp - PyString_AS_STRING(buf);
}示例3: write_data
void
write_data(fsinfo_t *fsopts, fsnode *node, unsigned char *buf, size_t len,
uint32_t ofs)
{
struct chfs_flash_data_node fdata;
memset(&fdata, 0, sizeof(fdata));
if (len == 0) {
return;
}
pad_block_if_less_than(fsopts, sizeof(fdata) + len);
fdata.magic = htole16(CHFS_FS_MAGIC_BITMASK);
fdata.type = htole16(CHFS_NODETYPE_DATA);
fdata.length = htole32(CHFS_PAD(sizeof(fdata) + len));
fdata.hdr_crc = htole32(crc32(0, (uint8_t *)&fdata,
CHFS_NODE_HDR_SIZE - 4));
fdata.vno = htole64(node->inode->ino);
fdata.data_length = htole32(len);
fdata.offset = htole32(ofs);
fdata.data_crc = htole32(crc32(0, (uint8_t *)buf, len));
fdata.node_crc = htole32(crc32(0,
(uint8_t *)&fdata, sizeof(fdata) - 4));
buf_write(fsopts, &fdata, sizeof(fdata));
buf_write(fsopts, buf, len);
padword(fsopts);
}示例4: write_dirent
void
write_dirent(fsinfo_t *fsopts, fsnode *node)
{
struct chfs_flash_dirent_node fdirent;
char *name;
name = emalloc(strlen(node->name));
memcpy(name, node->name, strlen(node->name));
memset(&fdirent, 0, sizeof(fdirent));
fdirent.magic = htole16(CHFS_FS_MAGIC_BITMASK);
fdirent.type = htole16(CHFS_NODETYPE_DIRENT);
fdirent.length = htole32(CHFS_PAD(sizeof(fdirent) + strlen(name)));
fdirent.hdr_crc = htole32(crc32(0, (uint8_t *)&fdirent,
CHFS_NODE_HDR_SIZE - 4));
fdirent.vno = htole64(node->inode->ino);
if (node->parent != NULL) {
fdirent.pvno = htole64(node->parent->inode->ino);
} else {
fdirent.pvno = htole64(node->inode->ino);
}
fdirent.version = htole64(version++);
fdirent.mctime = 0;
fdirent.nsize = htole32(strlen(name));
fdirent.dtype = htole32(IFTOCHT(node->type & S_IFMT));
fdirent.name_crc = htole32(crc32(0, (uint8_t *)name, fdirent.nsize));
fdirent.node_crc = htole32(crc32(0, (uint8_t *)&fdirent,
sizeof(fdirent) - 4));
pad_block_if_less_than(fsopts, sizeof(fdirent) + fdirent.nsize);
buf_write(fsopts, &fdirent, sizeof(fdirent));
buf_write(fsopts, name, fdirent.nsize);
padword(fsopts);
}示例5: START_TEST
END_TEST
START_TEST(test_integer)
{
#define OVERSIZE ":19223372036854775807\r\n"
#define INVALID1 ":123lOl456\r\n"
#define INVALID2 ":\r\n"
struct element el_c, el_p;
int ret;
struct int_pair {
char *serialized;
uint64_t num;
} pairs[3] = {
{":-1\r\n", -1},
{":9223372036854775807\r\n", 9223372036854775807},
{":128\r\n", 128}
};
test_reset();
for (int i = 0; i < 3; i++) {
size_t len = strlen(pairs[i].serialized);
buf_reset(buf);
el_c.type = ELEM_INT;
el_c.num = pairs[i].num;
ret = compose_element(&buf, &el_c);
ck_assert(ret == len);
ck_assert_int_eq(cc_bcmp(buf->rpos, pairs[i].serialized, len), 0);
el_p.type = ELEM_UNKNOWN;
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_OK);
ck_assert(buf->rpos == buf->wpos);
ck_assert(el_p.type == ELEM_INT);
ck_assert(el_p.num == pairs[i].num);
}
buf_reset(buf);
buf_write(buf, OVERSIZE, sizeof(OVERSIZE) - 1);
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_EOVERSIZE);
buf_reset(buf);
buf_write(buf, INVALID1, sizeof(INVALID1) - 1);
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_EINVALID);
buf_reset(buf);
buf_write(buf, INVALID2, sizeof(INVALID2) - 1);
ret = parse_element(&el_p, buf);
ck_assert_int_eq(ret, PARSE_EINVALID);
#undef INVALID2
#undef INVALID1
#undef OVERSIZE
}示例6: send_line_crlf
static bool
send_line_crlf (socket_descriptor_t sd,
const char *src)
{
bool ret;
struct buffer buf = alloc_buf (strlen (src) + 3);
ASSERT (buf_write (&buf, src, strlen (src)));
ASSERT (buf_write (&buf, "\r\n", 3));
ret = send_line (sd, BSTR (&buf));
free_buf (&buf);
return ret;
}示例7: adc_int_handler
static void adc_int_handler()
{
elua_adc_dev_state *d = adc_get_dev_state( 0 );
elua_adc_ch_state *s = d->ch_state[ d->seq_ctr ];
u32 tmp, dreg_t;
tmp = AD0STAT; // Clear interrupt flag
//AD0INTEN = 0; // Disable generating interrupts
dreg_t = *( PREG )adc_dr[ s->id ];
if ( dreg_t & ( 1UL << 31 ) )
{
d->sample_buf[ d->seq_ctr ] = ( u16 )( ( dreg_t >> 6 ) & 0x3FF );
AD0CR &= 0xF8FFFF00; // stop ADC, disable channels
s->value_fresh = 1;
if ( s->logsmoothlen > 0 && s->smooth_ready == 0)
adc_smooth_data( s->id );
#if defined( BUF_ENABLE_ADC )
else if ( s->reqsamples > 1 )
{
buf_write( BUF_ID_ADC, s->id, ( t_buf_data* )s->value_ptr );
s->value_fresh = 0;
}
#endif
if ( adc_samples_available( s->id ) >= s->reqsamples && s->freerunning == 0 )
{
platform_adc_stop( s->id );
}
}示例8: padword
static void
padword(fsinfo_t *fsopts)
{
if (img_ofs % 4) {
buf_write(fsopts, ffbuf, 4 - img_ofs % 4);
}
}示例9: write_vnode
void
write_vnode(fsinfo_t *fsopts, fsnode *node)
{
struct chfs_flash_vnode fvnode;
memset(&fvnode, 0, sizeof(fvnode));
fvnode.magic = htole16(CHFS_FS_MAGIC_BITMASK);
fvnode.type = htole16(CHFS_NODETYPE_VNODE);
fvnode.length = htole32(CHFS_PAD(sizeof(fvnode)));
fvnode.hdr_crc = htole32(crc32(0, (uint8_t *)&fvnode,
CHFS_NODE_HDR_SIZE - 4));
fvnode.vno = htole64(node->inode->ino);
fvnode.version = htole64(version++);
fvnode.mode = htole32(node->inode->st.st_mode);
fvnode.dn_size = htole32(node->inode->st.st_size);
fvnode.atime = htole32(node->inode->st.st_atime);
fvnode.ctime = htole32(node->inode->st.st_ctime);
fvnode.mtime = htole32(node->inode->st.st_mtime);
fvnode.gid = htole32(node->inode->st.st_uid);
fvnode.uid = htole32(node->inode->st.st_gid);
fvnode.node_crc = htole32(crc32(0, (uint8_t *)&fvnode,
sizeof(fvnode) - 4));
pad_block_if_less_than(fsopts, sizeof(fvnode));
buf_write(fsopts, &fvnode, sizeof(fvnode));
padword(fsopts);
}示例10: pgpdb_close
int pgpdb_close(KEYRING *keydb)
{
int err = 0;
if (keydb->modified) {
FILE *f;
#ifdef DEBUG
assert(keydb->writer);
#endif
if (keydb->encryptkey && keydb->encryptkey->length)
pgp_encrypt(PGP_NCONVENTIONAL | PGP_NOARMOR, keydb->db,
keydb->encryptkey, NULL, NULL, NULL, NULL);
assert(keydb->type == PGP_TYPE_PRIVATE || keydb->type == PGP_TYPE_PUBLIC);
if (keydb->filetype == ARMORED)
pgp_armor(keydb->db, keydb->type == PGP_TYPE_PUBLIC ? PGP_ARMOR_KEY : PGP_ARMOR_SECKEY);
if (keydb->filetype == -1 || (f = mix_openfile(keydb->filename,
keydb->filetype ==
ARMORED ? "w" : "wb"))
== NULL)
err = -1;
else {
err = buf_write(keydb->db, f);
fclose(f);
}
}
if (keydb->lock)
unlockfile(keydb->lock);
if (keydb->encryptkey)
buf_free(keydb->encryptkey);
buf_free(keydb->db);
free(keydb);
return (err);
}示例11: buf_assign
bool
buf_assign (struct buffer *dest, const struct buffer *src)
{
if (!buf_init (dest, src->offset))
return false;
return buf_write (dest, BPTR (src), BLEN (src));
}示例12: crypto_pem_encode
bool
crypto_pem_encode(const char *name, struct buffer *dst,
const struct buffer *src, struct gc_arena *gc)
{
bool ret = false;
BIO *bio = BIO_new(BIO_s_mem());
if (!bio || !PEM_write_bio(bio, name, "", BPTR(src), BLEN(src)))
{
ret = false;
goto cleanup;
}
BUF_MEM *bptr;
BIO_get_mem_ptr(bio, &bptr);
*dst = alloc_buf_gc(bptr->length, gc);
ASSERT(buf_write(dst, bptr->data, bptr->length));
ret = true;
cleanup:
if (!BIO_free(bio))
{
ret = false;;
}
return ret;
}示例13: write_eb_header
void
write_eb_header(fsinfo_t *fsopts)
{
chfs_opt_t *opts;
struct chfs_eb_hdr ebhdr;
char *buf;
opts = fsopts->fs_specific;
#define MINSIZE MAX(MAX(CHFS_EB_EC_HDR_SIZE, CHFS_EB_HDR_NOR_SIZE), \
CHFS_EB_HDR_NAND_SIZE)
if ((uint32_t)opts->pagesize < MINSIZE)
errx(EXIT_FAILURE, "pagesize cannot be less than %zu", MINSIZE);
buf = emalloc(opts->pagesize);
ebhdr.ec_hdr.magic = htole32(CHFS_MAGIC_BITMASK);
ebhdr.ec_hdr.erase_cnt = htole32(1);
ebhdr.ec_hdr.crc_ec = htole32(crc32(0,
(uint8_t *)&ebhdr.ec_hdr + 8, 4));
memcpy(buf, &ebhdr.ec_hdr, CHFS_EB_EC_HDR_SIZE);
memset(buf + CHFS_EB_EC_HDR_SIZE, 0xFF,
opts->pagesize - CHFS_EB_EC_HDR_SIZE);
buf_write(fsopts, buf, opts->pagesize);
memset(buf, 0xFF, opts->pagesize);
if (opts->mediatype == TYPE_NAND) {
ebhdr.u.nand_hdr.lid = htole32(lebnumber++);
ebhdr.u.nand_hdr.serial = htole64(++(max_serial));
ebhdr.u.nand_hdr.crc = htole32(crc32(0,
(uint8_t *)&ebhdr.u.nand_hdr + 4,
CHFS_EB_HDR_NAND_SIZE - 4));
memcpy(buf, &ebhdr.u.nand_hdr, CHFS_EB_HDR_NAND_SIZE);
} else {
ebhdr.u.nor_hdr.lid = htole32(lebnumber++);
ebhdr.u.nor_hdr.crc = htole32(crc32(0,
(uint8_t *)&ebhdr.u.nor_hdr + 4,
CHFS_EB_HDR_NOR_SIZE - 4));
memcpy(buf, &ebhdr.u.nor_hdr, CHFS_EB_HDR_NOR_SIZE);
}
buf_write(fsopts, buf, opts->pagesize);
free(buf);
}示例14: wsgi_getheaders
static size_t
wsgi_getheaders(Request* request, PyObject* buf)
{
char* bufp = PyString_AS_STRING(buf);
#define buf_write(src, len) \
do { \
size_t n = len; \
const char* s = src; \
while(n--) *bufp++ = *s++; \
} while(0)
#define buf_write2(src) buf_write(src, strlen(src))
/* First line, e.g. "HTTP/1.1 200 Ok" */
buf_write2("HTTP/1.1 ");
buf_write(PyString_AS_STRING(request->status),
PyString_GET_SIZE(request->status));
/* Headers, from the `request->headers` mapping.
* [("Header1", "value1"), ("Header2", "value2")]
* --> "Header1: value1\r\nHeader2: value2"
*/
for(Py_ssize_t i=0; i<PyList_GET_SIZE(request->headers); ++i) {
PyObject *tuple = PyList_GET_ITEM(request->headers, i);
PyObject *field = PyTuple_GET_ITEM(tuple, 0),
*value = PyTuple_GET_ITEM(tuple, 1);
buf_write2("\r\n");
buf_write(PyString_AS_STRING(field), PyString_GET_SIZE(field));
buf_write2(": ");
buf_write(PyString_AS_STRING(value), PyString_GET_SIZE(value));
}
/* See `wsgi_call_application` */
if(request->state.keep_alive) {
buf_write2("\r\nConnection: Keep-Alive");
if(request->state.chunked_response) {
buf_write2("\r\nTransfer-Encoding: chunked");
}
} else {
buf_write2("\r\nConnection: close");
}
buf_write2("\r\n\r\n");
return bufp - PyString_AS_STRING(buf);
}示例15: padblock
void
padblock(fsinfo_t *fsopts)
{
chfs_opt_t *chfs_opts = fsopts->fs_specific;
while (img_ofs % chfs_opts->eraseblock) {
buf_write(fsopts, ffbuf, MIN(sizeof(ffbuf),
chfs_opts->eraseblock - (img_ofs % chfs_opts->eraseblock)));
}
}