本文整理汇总了C++中bswap16函数的典型用法代码示例。如果您正苦于以下问题:C++ bswap16函数的具体用法?C++ bswap16怎么用?C++ bswap16使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了bswap16函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: first_bytes_header
int first_bytes_header(u16 seqnum, char *header, int header_len, char *buf, int buf_len){
int len;
len=encode_to_7bit(header, (buf_len+6)*2, 5);
if (len==-1){
return -1;
};
seqnum=bswap16(seqnum);
memcpy(header+len,(char *)&seqnum,2);
seqnum=bswap16(seqnum);
len+=2;
header[len]=buf_len+2;
len++;
header[len]=0x32;
len++;
seqnum--;
seqnum=bswap16(seqnum);
memcpy(header+len,(char *)&seqnum,2);
len+=2;
return len;
};
示例2: ffs_dinode2_swap
void
ffs_dinode2_swap(struct ufs2_dinode *o, struct ufs2_dinode *n)
{
n->di_mode = bswap16(o->di_mode);
n->di_nlink = bswap16(o->di_nlink);
n->di_uid = bswap32(o->di_uid);
n->di_gid = bswap32(o->di_gid);
n->di_blksize = bswap32(o->di_blksize);
n->di_size = bswap64(o->di_size);
n->di_blocks = bswap64(o->di_blocks);
n->di_atime = bswap64(o->di_atime);
n->di_atimensec = bswap32(o->di_atimensec);
n->di_mtime = bswap64(o->di_mtime);
n->di_mtimensec = bswap32(o->di_mtimensec);
n->di_ctime = bswap64(o->di_ctime);
n->di_ctimensec = bswap32(o->di_ctimensec);
n->di_birthtime = bswap64(o->di_ctime);
n->di_birthnsec = bswap32(o->di_ctimensec);
n->di_gen = bswap32(o->di_gen);
n->di_kernflags = bswap32(o->di_kernflags);
n->di_flags = bswap32(o->di_flags);
n->di_extsize = bswap32(o->di_extsize);
memcpy(n->di_extb, o->di_extb, sizeof(n->di_extb));
memcpy(n->di_db, o->di_db, sizeof(n->di_db));
memcpy(n->di_ib, o->di_ib, sizeof(n->di_ib));
}
示例3: process_tcp_pkt2
int process_tcp_pkt2(char *pkt, int pkt_len, int *last_recv_pkt_num) {
int ret;
RC4_crypt(pkt, pkt_len, &rc4_save, 0);
memcpy(last_recv_pkt_num,pkt+1,2);
*last_recv_pkt_num=bswap16(*last_recv_pkt_num);
(*last_recv_pkt_num)++;
*last_recv_pkt_num=bswap16(*last_recv_pkt_num);
show_memory(pkt,pkt_len,"result2:");
// supernode check
// if yet 06 0x21 blob, this is supernode reply
ret=main_unpack_test(pkt, pkt_len, 0x06, 0x21) ;
if (ret==0){
//printf("skype client, dumping nodes\n");
//main_unpack_saveip(pkt,pkt_len);
return -1;
};
return 0;
};
示例4: AsebaSendBuffer
extern "C" void AsebaSendBuffer(AsebaVMState *vm, const uint8* data, uint16 length)
{
Enki::AsebaMarxbot& marxBot = *asebaSocketMaps[vm];
Dashel::Stream* stream = marxBot.stream;
if (!stream)
return;
// send to stream
try
{
uint16 temp;
temp = bswap16(length - 2);
stream->write(&temp, 2);
temp = bswap16(vm->nodeId);
stream->write(&temp, 2);
stream->write(data, length);
stream->flush();
// push to other nodes
for (size_t i = 0; i < marxBot.modules.size(); ++i)
{
Enki::AsebaMarxbot::Module& module = *(marxBot.modules[i]);
if (&(module.vm) != vm)
{
module.events.push_back(Enki::AsebaMarxbot::Event(vm->nodeId, data, length));
AsebaProcessIncomingEvents(&(module.vm));
}
}
}
catch (Dashel::DashelException e)
{
std::cerr << "Cannot write to socket: " << stream->getFailReason() << std::endl;
}
}
示例5: dvb_desc_service_location_init
void dvb_desc_service_location_init(struct dvb_v5_fe_parms *parms, const uint8_t *buf, struct dvb_desc *desc)
{
struct dvb_desc_service_location *service_location = (struct dvb_desc_service_location *) desc;
uint8_t *endbuf = buf + desc->length;
ssize_t size = sizeof(struct dvb_desc_service_location) - sizeof(struct dvb_desc);
struct dvb_desc_service_location_element *element;
int i;
if (buf + size > endbuf) {
dvb_logerr("%s: short read %d/%zd bytes", __FUNCTION__, endbuf - buf, size);
return;
}
memcpy(desc->data, buf, size);
bswap16(service_location->bitfield);
buf += size;
if (service_location->elements == 0)
return;
size = service_location->elements * sizeof(struct dvb_desc_service_location_element);
if (buf + size > endbuf) {
dvb_logerr("%s: short read %d/%zd bytes", __FUNCTION__, endbuf - buf, size);
return;
}
service_location->element = malloc(size);
element = service_location->element;
for (i = 0; i < service_location->elements; i++) {
memcpy(element, buf, sizeof(struct dvb_desc_service_location_element) - 1); /* no \0 in lang */
buf += sizeof(struct dvb_desc_service_location_element) - 1;
element->language[3] = '\0';
bswap16(element->bitfield);
element++;
}
}
示例6: sizeof
struct mpeg_odsmt_section *mpeg_odsmt_section_codec(struct section_ext * ext)
{
struct mpeg_odsmt_section * odsmt = (struct mpeg_odsmt_section *)ext;
uint8_t * buf = (uint8_t *)ext;
size_t pos = sizeof(struct section_ext);
size_t len = section_ext_length(ext);
int i;
if (len < sizeof(struct mpeg_odsmt_section))
return NULL;
pos++;
if (odsmt->stream_count == 0) {
struct mpeg_odsmt_stream * stream =
(struct mpeg_odsmt_stream *) (buf + pos);
if ((pos + sizeof(struct mpeg_odsmt_stream_single)) > len)
return NULL;
bswap16(buf+pos);
pos+=3;
if ((pos + stream->u.single.es_info_length) >= len)
return NULL;
if (verify_descriptors(buf + pos, stream->u.single.es_info_length))
return NULL;
pos += stream->u.single.es_info_length;
} else {
for (i=0; i< odsmt->stream_count; i++) {
struct mpeg_odsmt_stream * stream =
(struct mpeg_odsmt_stream *)(buf + pos);
if ((pos + sizeof(struct mpeg_odsmt_stream_multi)) > len)
return NULL;
bswap16(buf+pos);
pos += sizeof(struct mpeg_odsmt_stream_multi);
if ((pos + stream->u.multi.es_info_length) > len)
return NULL;
if (verify_descriptors(buf + pos,
stream->u.multi.es_info_length))
return NULL;
pos += stream->u.multi.es_info_length;
}
}
if (pos != len)
return NULL;
return (struct mpeg_odsmt_section *) ext;
}
示例7: dvb_int_section_codec
struct dvb_int_section * dvb_int_section_codec(struct section_ext *ext)
{
uint8_t *buf = (uint8_t *) ext;
struct dvb_int_section *in = (struct dvb_int_section *) ext;
size_t pos = sizeof(struct section_ext);
size_t len = section_ext_length(ext);
if (len < sizeof(struct dvb_int_section))
return NULL;
bswap32(buf+8);
bswap16(buf+12);
pos += 6;
if (len - pos < in->platform_descriptors_length)
return NULL;
if (verify_descriptors(buf + pos, in->platform_descriptors_length))
return NULL;
pos += in->platform_descriptors_length;
while (pos < len) {
struct dvb_int_target *s2 = (struct dvb_int_target *) (buf + pos);
struct dvb_int_operational_loop *s3;
bswap16(buf + pos); /* target_descriptor_loop_length swap */
if (len - pos < s2->target_descriptors_length)
return NULL;
pos += sizeof(struct dvb_int_target);
if (verify_descriptors(buf + pos, s2->target_descriptors_length))
return NULL;
pos += s2->target_descriptors_length;
s3 = (struct dvb_int_operational_loop *) (buf + pos);
bswap16(buf + pos); /* operational_descriptor_loop_length swap */
if (len - pos < s3->operational_descriptors_length)
return NULL;
pos += sizeof(struct dvb_int_operational_loop);
if (verify_descriptors(buf + pos, s3->operational_descriptors_length))
return NULL;
pos += s3->operational_descriptors_length;
}
return (struct dvb_int_section *) ext;
}
示例8: sizeof
struct dvb_nit_section *dvb_nit_section_codec(struct section_ext * ext)
{
uint8_t * buf = (uint8_t *) ext;
struct dvb_nit_section * ret = (struct dvb_nit_section *) ext;
size_t pos = sizeof(struct section_ext);
size_t len = section_ext_length(ext);
if (len < sizeof(struct dvb_nit_section))
return NULL;
bswap16(buf + pos);
pos += 2;
if ((pos + ret->network_descriptors_length) > len)
return NULL;
if (verify_descriptors(buf + pos, ret->network_descriptors_length))
return NULL;
pos += ret->network_descriptors_length;
if ((pos + sizeof(struct dvb_nit_section_part2)) > len)
return NULL;
bswap16(buf + pos);
pos += 2;
while (pos < len) {
struct dvb_nit_transport *transport =
(struct dvb_nit_transport *)(buf + pos);
if ((pos + sizeof(struct dvb_nit_transport)) > len)
return NULL;
bswap16(buf + pos);
bswap16(buf + pos + 2);
bswap16(buf + pos + 4);
pos += sizeof(struct dvb_nit_transport);
if ((pos + transport->transport_descriptors_length) > len)
return NULL;
if (verify_descriptors(buf + pos,
transport->transport_descriptors_length))
return NULL;
pos += transport->transport_descriptors_length;
}
if (pos != len)
return NULL;
return ret;
}
示例9: dvb_table_sdt_init
void dvb_table_sdt_init(struct dvb_v5_fe_parms *parms, const uint8_t *buf,
ssize_t buflen, uint8_t *table, ssize_t *table_length)
{
const uint8_t *p = buf, *endbuf = buf + buflen - 4;
struct dvb_table_sdt *sdt = (void *)table;
struct dvb_table_sdt_service **head = &sdt->service;
size_t size = offsetof(struct dvb_table_sdt, service);
if (*table_length > 0) {
/* find end of curent list */
while (*head != NULL)
head = &(*head)->next;
} else {
if (p + size > endbuf) {
dvb_logerr("SDT table was truncated. Need %zu bytes, but has only %zu.",
size, buflen);
return;
}
memcpy(sdt, p, size);
*table_length = sizeof(struct dvb_table_sdt);
bswap16(sdt->network_id);
sdt->service = NULL;
}
p += size;
size = offsetof(struct dvb_table_sdt_service, descriptor);
while (p + size <= endbuf) {
struct dvb_table_sdt_service *service;
service = malloc(sizeof(struct dvb_table_sdt_service));
memcpy(service, p, size);
p += size;
bswap16(service->service_id);
bswap16(service->bitfield);
service->descriptor = NULL;
service->next = NULL;
*head = service;
head = &(*head)->next;
/* get the descriptors for each program */
dvb_parse_descriptors(parms, p, service->section_length,
&service->descriptor);
p += service->section_length;
}
if (endbuf - p)
dvb_logerr("PAT table has %zu spurious bytes at the end.",
endbuf - p);
}
示例10: glue
/* warning: addr must be aligned */
static inline uint32_t glue(address_space_lduw_internal, SUFFIX)(ARG1_DECL,
hwaddr addr, MemTxAttrs attrs, MemTxResult *result,
enum device_endian endian)
{
uint8_t *ptr;
uint64_t val;
MemoryRegion *mr;
hwaddr l = 2;
hwaddr addr1;
MemTxResult r;
bool release_lock = false;
RCU_READ_LOCK();
mr = TRANSLATE(addr, &addr1, &l, false);
if (l < 2 || !IS_DIRECT(mr, false)) {
release_lock |= prepare_mmio_access(mr);
/* I/O case */
r = memory_region_dispatch_read(mr, addr1, &val, 2, attrs);
#if defined(TARGET_WORDS_BIGENDIAN)
if (endian == DEVICE_LITTLE_ENDIAN) {
val = bswap16(val);
}
#else
if (endian == DEVICE_BIG_ENDIAN) {
val = bswap16(val);
}
#endif
} else {
/* RAM case */
ptr = MAP_RAM(mr, addr1);
switch (endian) {
case DEVICE_LITTLE_ENDIAN:
val = lduw_le_p(ptr);
break;
case DEVICE_BIG_ENDIAN:
val = lduw_be_p(ptr);
break;
default:
val = lduw_p(ptr);
break;
}
r = MEMTX_OK;
}
if (result) {
*result = r;
}
if (release_lock) {
qemu_mutex_unlock_iothread();
}
RCU_READ_UNLOCK();
return val;
}
示例11: swap
void
MsgTalk :: swap(uint8_t* aBuf) const
{
ASSERT(aBuf != nullptr);
MsgInfo* info = (MsgInfo*)aBuf;
info->Color = bswap32(info->Color);
info->Channel = bswap16(info->Channel);
info->Style = bswap16(info->Style);
info->Timestamp = bswap32(info->Timestamp);
}
示例12: make_tcp_pkt2
///////////////////////////////
//tcp second packet
////////////////////////////////
int make_tcp_pkt2(u16 seqnum, u32 rnd, char *pkt, int *pkt_len) {
int len;
u32 iv;
u8 result[0x1000];
int result_len;
//42394 - 0xA59A my iport
skype_thing mythings[] = {
{0, 0x01, 0x00000003, 0},
{1, 0x0D, 0xD6BA8CD9, 0x9205E2CD},
{0, 0x10, 0xA59A, 0},
};
int mythings_len=3;
u8 send_probe_pkt[]="\x30\xFF\xFF\x13\xF2\x01\xFF\xFF\x42\x44\x40\xFA\x3B\x4C\xE4\xAF\x94\xD9\x8C\xBA\xD6\xCD\xE2\x05\x92";
len=sizeof(send_probe_pkt)-1;
//main_unpack(send_probe_pkt,len);
result_len=main_pack(mythings, mythings_len, result, sizeof(result)-1 );
//show_memory(result,nlen,"packed42:");
//main_unpack(result,nlen);
memcpy(send_probe_pkt+8,result,result_len);
show_memory(send_probe_pkt,len,"send pkt2:");
seqnum=bswap16(seqnum);
memcpy(send_probe_pkt+1,(char *)&seqnum,2);
seqnum=bswap16(seqnum);
seqnum=bswap16(seqnum-1);
memcpy(send_probe_pkt+6,(char *)&seqnum,2);
seqnum=bswap16(seqnum-1);
iv = rnd;
Skype_RC4_Expand_IV (&rc4, iv, 1);
RC4_crypt (send_probe_pkt, len, &rc4, 0);
memcpy(pkt,send_probe_pkt,len);
*pkt_len=len;
return 0;
};
示例13: incomingData
virtual void incomingData(Dashel::Stream *stream)
{
uint16 temp;
uint16 len;
stream->read(&temp, 2);
len = bswap16(temp);
stream->read(&temp, 2);
lastMessageSource = bswap16(temp);
lastMessageData.resize(len+2);
stream->read(&lastMessageData[0], lastMessageData.size());
AsebaProcessIncomingEvents(&vm);
}
示例14: bswap16
void DualshockPad::receivedHIDReport(const uint8_t* data, size_t length, HIDReportType tp, uint32_t message) {
if (message != 1 || length != 49 || tp != HIDReportType::Input)
return;
DualshockPadState state = *reinterpret_cast<const DualshockPadState*>(data);
for (int i = 0; i < 3; i++)
state.m_accelerometer[i] = bswap16(state.m_accelerometer[i]);
state.m_gyrometerZ = bswap16(state.m_gyrometerZ);
const double zeroG = 511.5; // 1.65/3.3*1023 (1,65V);
float accXval = -((double)state.m_accelerometer[0] - zeroG);
float accYval = -((double)state.m_accelerometer[1] - zeroG);
float accZval = -((double)state.m_accelerometer[2] - zeroG);
state.accPitch = (atan2(accYval, accZval) + M_PIF) * RAD_TO_DEG;
state.accYaw = (atan2(accXval, accZval) + M_PIF) * RAD_TO_DEG;
state.gyroZ = (state.m_gyrometerZ / 1023.f);
{
std::lock_guard<std::mutex> lk(m_callbackLock);
if (m_callback)
m_callback->controllerUpdate(*this, state);
}
if (m_rumbleRequest != m_rumbleState) {
if (True(m_rumbleRequest & EDualshockMotor::Left)) {
m_report.rumble.leftDuration = m_rumbleDuration[0];
m_report.rumble.leftForce = m_rumbleIntensity[0];
} else {
m_report.rumble.leftDuration = 0;
m_report.rumble.leftForce = 0;
}
if (True(m_rumbleRequest & EDualshockMotor::Right)) {
m_report.rumble.rightDuration = m_rumbleDuration[1];
m_report.rumble.rightOn = m_rumbleIntensity[1] > 0;
} else {
m_report.rumble.rightDuration = 0;
m_report.rumble.rightOn = false;
}
sendHIDReport(m_report.buf, sizeof(m_report), HIDReportType::Output, 0x01);
m_rumbleState = m_rumbleRequest;
} else {
if (state.m_reserved5[8] & 0x80)
m_rumbleRequest &= ~EDualshockMotor::Right;
if (state.m_reserved5[7] & 0x01)
m_rumbleRequest &= ~EDualshockMotor::Left;
m_rumbleState = m_rumbleRequest;
}
}
示例15: make_tcp_pkt3
///////////////////////////////
//tcp third packet
////////////////////////////////
int make_tcp_pkt3(u16 seqnum, u32 rnd, char *pkt, int *pkt_len) {
int len;
u8 result[0x1000];
int result_len;
skype_thing mythings[] = {
{0, 0x04, 0x10, 0},
{0, 0x05, 0x06, 0},
};
int mythings_len=2;
//u8 send_probe_pkt[]="\x16\xFF\xFF\x06\x82\x03\xFF\xFF\x42\x33\x48\x93";
u8 send_probe_pkt[]="\x14\xFF\xFF\x06\x32\xFF\xFF\x42\x85\x14\xC9";
len=sizeof(send_probe_pkt)-1;
//main_unpack(send_probe_pkt,len);
result_len=main_pack(mythings, mythings_len, result, sizeof(result)-1 );
//show_memory(result,result_len,"packed42:");
//main_unpack(result,result_len);
memcpy(send_probe_pkt+7,result,result_len);
show_memory(send_probe_pkt,len,"send pkt3:");
//seq
seqnum=bswap16(seqnum);
memcpy(send_probe_pkt+1,(char *)&seqnum,2);
seqnum=bswap16(seqnum);
seqnum--;
seqnum=bswap16(seqnum);
memcpy(send_probe_pkt+5,(char *)&seqnum,2);
seqnum=bswap16(seqnum);
len=0;
memcpy(pkt+len,send_probe_pkt,sizeof(send_probe_pkt)-1);
len+=sizeof(send_probe_pkt)-1;
RC4_crypt (pkt, len, &rc4, 0);
*pkt_len=len;
return 0;
};