const void*
rpacket_read_binary(rpacket *r,uint16_t *len)
{
void *addr = 0;
uint16_t size = rpacket_read_uint16(r);
if(size == 0 || size > r->data_remain) return NULL;
if(len) *len = size;
if(reader_check_size(&r->reader,size)){
addr = &r->reader.cur->data[r->reader.pos];
r->reader.pos += size;
r->data_remain -= size;
if(r->data_remain && r->reader.pos >= r->reader.cur->size)
buffer_reader_init(&r->reader,r->reader.cur->next,0);
}else{
if(!r->binbuf){
r->binbuf = bytebuffer_new(((packet*)r)->len_packet);
r->binpos = 0;
}
addr = r->binbuf->data + r->binpos;
while(size)
{
uint32_t copy_size = r->reader.cur->size - r->reader.pos;
copy_size = copy_size >= size ? size:copy_size;
memcpy(r->binbuf->data + r->binpos,r->reader.cur->data + r->reader.pos,copy_size);
size -= copy_size;
r->reader.pos += copy_size;
r->data_remain -= copy_size;
r->binpos += copy_size;
if(r->data_remain && r->reader.pos >= r->reader.cur->size)
buffer_reader_init(&r->reader,r->reader.cur->next,0);
}
}
return addr;
}
packet*
wpacket_makeread(packet *p)
{
if(p->type == WPACKET){
rpacket *r = rpacket_new(NULL,0);
((packet*)r)->head = p->head;
refobj_inc((refobj*)p->head);
((packet*)r)->spos = p->spos;
buffer_reader_init(&r->reader,p->head,p->spos + SIZE_HEAD);
((packet*)r)->len_packet = p->len_packet;
r->data_remain = p->len_packet - SIZE_HEAD;
INIT_CONSTROUCTOR(r);
return (packet*)r;
}
return NULL;
}
rpacket*
rpacket_new(bytebuffer *b,uint32_t start_pos)
{
rpacket *r = (rpacket*)CALLOC(g_rpk_allocator,1,sizeof(*r));
((packet*)r)->type = RPACKET;
if(b){
((packet*)r)->head = b;
((packet*)r)->spos = start_pos;
refobj_inc((refobj*)b);
buffer_reader_init(&r->reader,b,start_pos);
buffer_read(&r->reader,&r->data_remain,sizeof(r->data_remain));
((packet*)r)->len_packet = r->data_remain + SIZE_HEAD;
}
INIT_CONSTROUCTOR(r);
return r;
}
static packet*
rpacket_clone(packet *p)
{
rpacket *ori = (rpacket*)p;
if(p->type == RPACKET){
rpacket *r = rpacket_new(NULL,0);
((packet*)r)->head = p->head;
refobj_inc((refobj*)p->head);
((packet*)r)->spos = p->spos;
buffer_reader_init(&r->reader,ori->reader.cur,ori->reader.pos);
((packet*)r)->len_packet = p->len_packet;
r->data_remain = p->len_packet - SIZE_HEAD;
INIT_CONSTROUCTOR(r);
return (packet*)r;
}
return NULL;
}
void pt_srv_receive(struct pt_sclient *user, struct pt_buffer *buff)
{
buffer_reader reader;
struct net_header hdr;
buffer_reader_init(&reader, buff);
buffer_reader_read(&reader, (unsigned char*)&hdr, sizeof(hdr));
buffer_reader_ignore_bytes(&reader, 4);
char *s = (char*)buffer_reader_cur_pos(&reader);
printf("%s\n",s);
//printf("pt_srv_receive => %d\n",user->serial);
pt_srv_send(user);
}
static packet*
rpk_unpack(decoder *d,int32_t *err)
{
TYPE_HEAD pk_len;
uint32_t pk_total,size;
buffer_reader reader;
rpacket *rpk;
if(err) *err = 0;
if(d->size <= SIZE_HEAD)
return NULL;
buffer_reader_init(&reader,d->buff,d->pos);
if(SIZE_HEAD != buffer_read(&reader,(char*)&pk_len,SIZE_HEAD))
return NULL;
pk_len = _ntoh16(pk_len);
pk_total = pk_len + SIZE_HEAD;
if(pk_total > d->max_packet_size){
if(err) *err = DERR_TOOLARGE;
return NULL;
}
if(pk_total > d->size)
return NULL;
rpk = rpacket_new(d->buff,d->pos);
do{
size = d->buff->size - d->pos;
size = pk_total > size ? size:pk_total;
d->pos += size;
pk_total -= size;
d->size -= size;
if(d->pos >= d->buff->cap)
{
bytebuffer_set(&d->buff,d->buff->next);
d->pos = 0;
if(!d->buff){
assert(pk_total == 0);
break;
}
}
}while(pk_total);
return (packet*)rpk;
}
