static const char* markup_unescape2(const char *in, char **out, size_t *size)
{
unsigned int n;
char temp[2], buf[7];
while (*in != 0) {
if (*in == '&' && *(in + 1) == '#'
&& (sscanf(in, "&#%u%1[;]", &n, temp) == 2
|| sscanf(in, "&#x%x%1[;]", &n, temp) == 2)
&& n != 0)
{
size_t buflen = uni2utf8(n, buf, sizeof(buf));
if (copy_buf(out, size, buf, buflen) > 0)
break;
n = *(in + 2) == 'x' ? 3 : 2;
while (isxdigit(in[n]))
n++;
if(in[n] == ';')
n++;
in += n;
} else {
if (*size <= 0)
break;
**out = *in++;
*out += 1;
*size -= 1;
}
}
return in;
}
const char *acl_xml_encode2(const char *in, size_t ilen, char **out, size_t *olen)
{
const unsigned char *ptr = (const unsigned char*) in;
const char *s;
if (*olen == 0)
return in;
*olen -= 1; /* reserve space for '\0' */
while (ilen > 0) {
if ((s = __charmap[*ptr]) != NULL) {
if (copy_buf(out, olen, s, strlen(s)) > 0)
break;
} else if (*olen > 0) {
**out = *ptr;
*out += 1;
*olen -= 1;
if (*olen == 0)
break;
} else
break;
ptr++;
ilen--;
}
**out = '\0';
*out += 1;
return (const char*) ptr;
}
int ft_gnl(int const fd, char **line)
{
int ret;
char *tmp;
static char buf[GNL_BUFF_SIZE];
tmp = NULL;
ft_memdel((void **)line);
if (fd < 0 || !line)
return (-1);
if (*buf)
if ((ret = copy_buf(buf, &tmp, 0)))
return ((*line = tmp) ? ret : ret);
while ((ret = read(fd, buf, GNL_BUFF_SIZE)) > 0)
if ((ret = copy_buf(buf, &tmp, 1)))
return ((*line = tmp) ? ret : ret);
return (((*line = tmp) && ret != -1 && *tmp) ? 1 : ret);
}
int read_file(int fd , char const *uptime , size_t uptimelen , int outfd , char *outbuf ,
size_t *outlen )
{
int tmp ;
int tmp___0 ;
int tmp___1 ;
{
{
#line 132
lseek(fd, (__off_t )0, 0);
#line 134
tmp = append_buf(uptime, uptimelen, outfd, outbuf, outlen);
}
#line 134
if (tmp < 0) {
#line 135
return (-1);
}
{
#line 137
tmp___0 = copy_buf(fd, outfd, outbuf, outlen);
}
#line 137
if (tmp___0 < 0) {
#line 138
return (-1);
}
{
#line 140
tmp___1 = append_buf("\n", (size_t )1, outfd, outbuf, outlen);
}
#line 140
if (tmp___1 < 0) {
#line 141
return (-1);
}
#line 143
return (0);
}
}
void ofxSyncClient::synchronize() {
// send data!
std::iostream o(&request_);
//ldir: "client" directory which we want to keep up2date
//rdit: the "remote" directory on server with which we want to sync
std::string ldir = "/Users/diederickhuijbers/Documents/programming/c++/of61fatxcode/apps/diederick/0059_sync_client/bin/data/test/";
std::string rdir = "/Users/diederickhuijbers/Documents/programming/c++/of61fatxcode/apps/diederick/0058_sync_server/bin/data/images/";
//o << "local_dir" << std::endl;
//o << "remote_dir" << std::endl;
dir_list_.getList(ldir, o);
std::cout << "synchronize!" <<std::endl;
uint32_t size = request_.size();
uint32_t transfer_port = atoi(transfer_server_port_.c_str());
std::iostream copy_buf(&size_buf_);
copy_buf.write((char*)&size, sizeof(size));
copy_buf.write((char*)&transfer_port, sizeof(transfer_port));
ldir += "\n";
rdir += "\n";
copy_buf.write(ldir.c_str(), ldir.size());
copy_buf.write(rdir.c_str(), rdir.size());
copy_buf.write("\n", 1);
cout << "size: "<< request_.size() << std::endl;
boost::asio::async_write(
socket_
,size_buf_
,boost::bind(
&ofxSyncClient::handleSize
,shared_from_this()
,boost::asio::placeholders::error
)
);
//io_service_.run_one();
}
static int reassemble(struct net_buf *mbuf)
{
/* size of the IP packet (read from fragment) */
uint16_t frag_size = 0;
int8_t frag_context = 0;
/* offset of the fragment in the IP packet */
uint8_t frag_offset = 0;
uint8_t is_fragment = 0;
/* tag of the fragment */
uint16_t frag_tag = 0;
uint8_t first_fragment = 0, last_fragment = 0;
struct net_buf *buf = NULL;
/* init */
uip_uncomp_hdr_len(mbuf) = 0;
uip_packetbuf_hdr_len(mbuf) = 0;
/* The MAC puts the 15.4 payload inside the packetbuf data buffer */
uip_packetbuf_ptr(mbuf) = packetbuf_dataptr(mbuf);
/* Save the RSSI of the incoming packet in case the upper layer will
want to query us for it later. */
last_rssi = (signed short)packetbuf_attr(mbuf, PACKETBUF_ATTR_RSSI);
/*
* Since we don't support the mesh and broadcast header, the first header
* we look for is the fragmentation header
*/
switch((GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_DISPATCH_SIZE) & 0xf800) >> 8) {
case SICSLOWPAN_DISPATCH_FRAG1:
PRINTF("reassemble: FRAG1 ");
frag_offset = 0;
frag_size = GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_DISPATCH_SIZE) & 0x07ff;
frag_tag = GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_TAG);
PRINTF("size %d, tag %d, offset %d\n", frag_size, frag_tag, frag_offset);
if (frag_size > IP_BUF_MAX_DATA) {
PRINTF("Too big packet %d bytes (max %d), fragment discarded\n",
frag_size, IP_BUF_MAX_DATA);
goto fail;
}
uip_packetbuf_hdr_len(mbuf) += SICSLOWPAN_FRAG1_HDR_LEN;
first_fragment = 1;
is_fragment = 1;
/* Add the fragment to the fragmentation context (this will also copy the payload)*/
frag_context = add_fragment(mbuf, frag_tag, frag_size, frag_offset);
if(frag_context == -1) {
goto fail;
}
break;
case SICSLOWPAN_DISPATCH_FRAGN:
/*
* set offset, tag, size
* Offset is in units of 8 bytes
*/
PRINTF("reassemble: FRAGN ");
frag_offset = uip_packetbuf_ptr(mbuf)[PACKETBUF_FRAG_OFFSET];
frag_tag = GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_TAG);
frag_size = GET16(uip_packetbuf_ptr(mbuf), PACKETBUF_FRAG_DISPATCH_SIZE) & 0x07ff;
PRINTF("reassemble: size %d, tag %d, offset %d\n", frag_size, frag_tag, frag_offset);
uip_packetbuf_hdr_len(mbuf) += SICSLOWPAN_FRAGN_HDR_LEN;
/* If this is the last fragment, we may shave off any extrenous
bytes at the end. We must be liberal in what we accept. */
/* Add the fragment to the fragmentation context (this will also copy the payload) */
frag_context = add_fragment(mbuf, frag_tag, frag_size, frag_offset);
if(frag_context == -1) {
goto fail;
}
if(frag_info[frag_context].reassembled_len >= frag_size) {
last_fragment = 1;
}
is_fragment = 1;
break;
default:
/* If there is no fragmentation header, then assume that the packet
* is not fragmented and pass it as is to IP stack.
*/
buf = copy_buf(mbuf);
if(!buf || net_driver_15_4_recv(buf) < 0) {
goto fail;
}
goto out;
}
/*
* copy "payload" from the packetbuf buffer to the sicslowpan_buf
* if this is a first fragment or not fragmented packet,
* we have already copied the compressed headers, uncomp_hdr_len
* and packetbuf_hdr_len are non 0, frag_offset is.
* If this is a subsequent fragment, this is the contrary.
*/
if(packetbuf_datalen(mbuf) < uip_packetbuf_hdr_len(mbuf)) {
PRINTF("reassemble: packet dropped due to header > total packet\n");
goto fail;
}
uip_packetbuf_payload_len(mbuf) = packetbuf_datalen(mbuf) - uip_packetbuf_hdr_len(mbuf);
/* Sanity-check size of incoming packet to avoid buffer overflow */
{
int req_size = UIP_LLH_LEN + (uint16_t)(frag_offset << 3)
+ uip_packetbuf_payload_len(mbuf);
if(req_size > UIP_BUFSIZE) {
PRINTF("reassemble: packet dropped, minimum required IP_BUF size: %d+%d+%d=%d (current size: %d)\n", UIP_LLH_LEN, (uint16_t)(frag_offset << 3),
uip_packetbuf_payload_len(mbuf), req_size, UIP_BUFSIZE);
goto fail;
}
}
if(frag_size > 0) {
/* Add the size of the header only for the first fragment. */
if(first_fragment != 0) {
frag_info[frag_context].reassembled_len = uip_uncomp_hdr_len(mbuf) + uip_packetbuf_payload_len(mbuf);
}
/* For the last fragment, we are OK if there is extrenous bytes at
the end of the packet. */
if(last_fragment != 0) {
frag_info[frag_context].reassembled_len = frag_size;
/* copy to uip(net_buf) */
buf = copy_frags2uip(frag_context);
if(!buf)
goto fail;
}
}
/*
* If we have a full IP packet in sicslowpan_buf, deliver it to
* the IP stack
*/
if(!is_fragment || last_fragment) {
/* packet is in uip already - just set length */
if(is_fragment != 0 && last_fragment != 0) {
uip_len(buf) = frag_size;
} else {
uip_len(buf) = uip_packetbuf_payload_len(mbuf) + uip_uncomp_hdr_len(mbuf);
}
PRINTF("reassemble: IP packet ready (length %d)\n", uip_len(buf));
if(net_driver_15_4_recv(buf) < 0) {
goto fail;
}
}
out:
/* free MAC buffer */
l2_buf_unref(mbuf);
return 1;
fail:
if(buf) {
ip_buf_unref(buf);
}
return 0;
}
int read_proc(DIR *proc , char const *uptime , size_t uptimelen , int outfd , char *outbuf ,
size_t *outlen )
{
struct dirent *ent ;
int tmp ;
char filename[4096] ;
int fd ;
int tmp___0 ;
int tmp___1 ;
int tmp___2 ;
{
{
#line 156
rewinddir(proc);
#line 158
tmp = append_buf(uptime, uptimelen, outfd, outbuf, outlen);
}
#line 158
if (tmp < 0) {
#line 159
return (-1);
}
{
#line 161
while (1) {
while_continue: /* CIL Label */ ;
{
#line 161
ent = readdir(proc);
}
#line 161
if (! ((unsigned long )ent != (unsigned long )((void *)0))) {
#line 161
goto while_break;
}
#line 165
if ((int )ent->d_name[0] < 48) {
#line 166
goto while_continue;
} else
#line 165
if ((int )ent->d_name[0] > 57) {
#line 166
goto while_continue;
}
{
#line 168
sprintf((char */* __restrict */)(filename), (char const */* __restrict */)"/proc/%s/stat",
ent->d_name);
#line 170
fd = open((char const *)(filename), 0);
}
#line 171
if (fd < 0) {
#line 172
goto while_continue;
}
{
#line 174
tmp___0 = copy_buf(fd, outfd, outbuf, outlen);
#line 177
tmp___1 = close(fd);
}
#line 177
if (tmp___1 < 0) {
#line 178
goto while_continue;
}
}
while_break: /* CIL Label */ ;
}
{
#line 181
tmp___2 = append_buf("\n", (size_t )1, outfd, outbuf, outlen);
}
#line 181
if (tmp___2 < 0) {
#line 182
return (-1);
}
#line 184
return (0);
}
}
