void *udp_packet_handler(void *arg)
{
(void) arg;
msg_t m_recv_ip, m_send_ip, m_recv_udp, m_send_udp;
socket_internal_t *udp_socket = NULL;
msg_init_queue(udp_msg_queue, UDP_PKT_RECV_BUF_SIZE);
while (1) {
msg_receive(&m_recv_ip);
ipv6_hdr_t *ipv6_header = ((ipv6_hdr_t *)m_recv_ip.content.ptr);
udp_hdr_t *udp_header = ((udp_hdr_t *)(m_recv_ip.content.ptr + IPV6_HDR_LEN));
uint16_t chksum = ipv6_csum(ipv6_header, (uint8_t*) udp_header, NTOHS(udp_header->length), IPPROTO_UDP);
if (chksum == 0xffff) {
udp_socket = get_udp_socket(udp_header);
if (udp_socket != NULL) {
m_send_udp.content.ptr = (char *)ipv6_header;
msg_send_receive(&m_send_udp, &m_recv_udp, udp_socket->recv_pid);
}
else {
printf("Dropped UDP Message because no thread ID was found for delivery!\n");
}
}
else {
printf("Wrong checksum (%x)!\n", chksum);
}
msg_reply(&m_recv_ip, &m_send_ip);
}
}
void udp_packet_handler(void)
{
msg_t m_recv_ip, m_send_ip, m_recv_udp, m_send_udp;
ipv6_hdr_t *ipv6_header;
udp_hdr_t *udp_header;
uint8_t *payload;
socket_internal_t *udp_socket = NULL;
uint16_t chksum;
while (1) {
msg_receive(&m_recv_ip);
ipv6_header = ((ipv6_hdr_t *)m_recv_ip.content.ptr);
udp_header = ((udp_hdr_t *)(m_recv_ip.content.ptr + IPV6_HDR_LEN));
payload = (uint8_t *)(m_recv_ip.content.ptr + IPV6_HDR_LEN + UDP_HDR_LEN);
chksum = udp_csum(ipv6_header, udp_header);
if (chksum == 0xffff) {
udp_socket = get_udp_socket(ipv6_header, udp_header);
if (udp_socket != NULL) {
m_send_udp.content.ptr = (char *)ipv6_header;
msg_send_receive(&m_send_udp, &m_recv_udp, udp_socket->recv_pid);
}
else {
printf("Dropped UDP Message because no thread ID was found for delivery!\n");
}
}
else {
printf("Wrong checksum (%x)!\n", chksum);
}
msg_reply(&m_recv_ip, &m_send_ip);
}
}
int main(int argc, char **argv){
int sockfd_fp, sockfd_data, connfd, udpfd, nready, maxfdp1;
char mesg[MAXLINE];
pid_t childpid, workerpid;
fd_set rset;
const int on = 1;
void sig_chld(int);
// hash worker init
hash_init(1024);
/* 1. Channel : fingerprint packet recv */
sockfd_fp = get_udp_socket(SERV_PORT+1);
/* 2. Channel : other packet */
sockfd_data = get_udp_socket(SERV_PORT);
Signal(SIGCHLD, sig_chld); /* must call waitpid() */
FD_ZERO(&rset);
maxfdp1 = max(sockfd_fp, sockfd_data) + 1;
for ( ; ; ) {
FD_SET(sockfd_fp, &rset);
FD_SET(sockfd_data, &rset);
if ( (nready = select(maxfdp1, &rset, NULL, NULL, NULL)) < 0) {
if (errno == EINTR)
continue; /* back to for() */
else
err_sys("select error");
}
if (FD_ISSET(sockfd_fp, &rset)) {
recv_fp(sockfd_fp);
}
if (FD_ISSET(sockfd_data, &rset)) {
recv_chunk(sockfd_data);
}
}
}
int main(int argc, char **argv){
int res = 0;
struct timeval tv1, tv2;
double total;
char *directory = NULL;
long count;
if (argc != 3)
err_quit("usage: client <IPaddress> <file dir>");
serverip = argv[1];
directory = argv[2];
gettimeofday(&tv1, NULL);
sockfd4pox = get_udp_socket(QUICK_PORT);// channel with POX
bzero(&servaddrfp, sizeof(servaddrfp));
servaddrfp.sin_family = AF_INET;
servaddrfp.sin_port = htons(SERV_PORT+1);
Inet_pton(AF_INET, argv[1], &servaddrfp.sin_addr);
sockfd2serverfp = Socket(AF_INET, SOCK_DGRAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
sockfd2server = Socket(AF_INET, SOCK_DGRAM, 0);
uploadDir(directory);
gettimeofday(&tv2, NULL);
printf("Time cost = %lfms\n",(tv2.tv_sec-tv1.tv_sec)*1000.0+(tv2.tv_usec-tv1.tv_usec)/1000.0);
close(sockfd4pox);
close(sockfd2server);
close(sockfd2serverfp);
exit(0);
}
int get_multicast_socket(const char *group, unsigned short port)
{
int fd;
struct ip_mreq mreq;
if ((fd = get_udp_socket(group, port)) < 0) {
printf("Could not get UDP socket.\n");
return (-1);
}
/* use setsockopt() to request that the kernel join a multicast group */
mreq.imr_multiaddr.s_addr = inet_addr(group);
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) <
0) {
printf
("%s:setsockopt() failed: Join multicast group failed: %s\n",
progname, strerror(errno));
return (-1);
}
return (fd);
}
// application entry point
int main(int argc, char* argv[])
{
int fbfd = 0;
struct fb_var_screeninfo orig_vinfo;
struct fb_var_screeninfo vinfo;
struct fb_fix_screeninfo finfo;
long int screensize = 0;
char *fbp = 0;
char packet[1120];
ssize_t packet_size;
int sock_fd = get_udp_socket(UDP_PORT);
// Open the file for reading and writing
fbfd = open("/dev/fb0", O_RDWR);
if (!fbfd) {
die("Error: cannot open framebuffer device.\n");
}
printf("The framebuffer device was opened successfully.\n");
// Get variable screen information
if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo)) {
printf("Error reading variable information.\n");
}
printf("Original %dx%d, %dbpp\n", vinfo.xres, vinfo.yres,
vinfo.bits_per_pixel );
// Store for reset (copy vinfo to vinfo_orig)
memcpy(&orig_vinfo, &vinfo, sizeof(struct fb_var_screeninfo));
// Change variable info
vinfo.bits_per_pixel = 24;
if (ioctl(fbfd, FBIOPUT_VSCREENINFO, &vinfo)) {
printf("Error setting variable information.\n");
}
// Get fixed screen information
if (ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo)) {
printf("Error reading fixed information.\n");
}
// map fb to user mem
screensize = finfo.smem_len;
fbp = (char*)mmap(0,
screensize,
PROT_READ | PROT_WRITE,
MAP_SHARED,
fbfd,
0);
if ((long)fbp == -1) {
die("Failed to mmap.\n");
}
else {
// draw...
int x, y, pixelcount;
unsigned int color = 0;
int pixeloffset = 2;
int pixellength = 0;
unsigned int pix_offset;
unsigned bpp = vinfo.bits_per_pixel / 8;
while( (packet_size = get_udp_packet(sock_fd, packet, sizeof(packet))) >= 0 ) {
if((uint8_t)packet[0] == 1){
pixellength = 8;
} else {
pixellength = 7;
}
// how many pixels
pixelcount = (packet_size-1)/pixellength;
//printf("%d pixels in packet of size: %d using a pixel size of: %d \n", pixelcount, packet_size, pixellength);
// fetch a pixel from the udp socket
int i = 0;
for(i=pixeloffset; // skip pixeloffset
i<packet_size-(pixellength-1); // walk trough all bytes untill we get to the end minus one package length
i+=pixellength){
x = (uint8_t)packet[i ] + (((uint8_t)packet[i+1])<<8);
y = (uint8_t)packet[i+2] + (((uint8_t)packet[i+3])<<8);
//printf("%d %d %d %d %d %d\n", x, y, packet[i ], packet[i+1], packet[i+2], packet[i+3]);
if(x < vinfo.xres && y < vinfo.yres){
pix_offset = bpp * x + y * finfo.line_length;
fbp[pix_offset++] = packet[i+6];
fbp[pix_offset++] = packet[i+5];
fbp[pix_offset] = packet[i+4];
}
}
}
}
// cleanup
munmap((void *)fbp, screensize);
if (ioctl(fbfd, FBIOPUT_VSCREENINFO, &orig_vinfo)) {
printf("Error re-setting variable information.\n");
}
close(fbfd);
return 0;
}
// application entry point
int main(int argc, char* argv[]) {
uint8_t packet[ (8 * MAX_PIXELS) + 32]; // 8 bytes per pixel is the maximum size
ssize_t packet_size;
uint16_t x, y;
uint8_t r, g, b, a;
uint8_t pixellength = 0, protocol, version;
uint16_t i;
uint8_t offset = 2;
int sock_fd = get_udp_socket(UDP_PORT);
// Init screen buffer
if (!init_frame_buffer()) {
die("Failed to init screen buffer.\n");
}
// draw each udp packet
while( (packet_size = get_udp_packet(sock_fd, (char*)&packet, sizeof(packet))) >= 0 ) {
// Get protocol from the packet
version = packet[1]; // the version
protocol = packet[0]; // protocol switch
//printf("V:%d, P:%d\n", version, protocol);
switch (protocol) {
// Protocol 0: xyrgb 16:16:8:8:8 specified for each pixel
case 0:
pixellength = 7;
packet_size = MIN(offset + (pixellength * MAX_PIXELS), packet_size);
for (i=offset; i<packet_size; i+=pixellength) {
x = packet[i ] | packet[i+1]<<8;
y = packet[i+2] | packet[i+3]<<8;
r = packet[i+4];
g = packet[i+5];
b = packet[i+6];
a = 0xFF;
write_pixel_to_screen(x, y, r, g, b, a);
}
break;
// Protocol 1: xyrgba 16:16:8:8:8:8 specified for each pixel
case 1:
pixellength = 8;
packet_size = MIN(offset + (pixellength * MAX_PIXELS), packet_size);
for (i=offset; i<packet_size; i+=pixellength) {
x = packet[i ] | packet[i+1]<<8;
y = packet[i+2] | packet[i+3]<<8;
r = packet[i+4];
g = packet[i+5];
b = packet[i+6];
a = packet[i+7];
write_pixel_to_screen(x, y, r, g, b, a);
}
break;
// Protocol 2: xyrgb 12:12:8:8:8 specified for each pixel
case 2:
pixellength = 6;
packet_size = MIN(offset + (pixellength * MAX_PIXELS), packet_size);
for (i=offset; i<packet_size; i+=pixellength) {
x = packet[i ] | (packet[i+1]&0xF0)<<4;
y = (packet[i+1]&0x0F) | packet[i+2]<<4;
r = packet[i+3];
g = packet[i+4];
b = packet[i+5];
a = 0xFF;
write_pixel_to_screen(x, y, r, g, b, a);
}
break;
// Protocol 3: xyrgba 12:12:8:8:8:8 specified for each pixel
case 3:
pixellength = 7;
packet_size = MIN(offset + (pixellength * MAX_PIXELS), packet_size);
for (i=offset; i<packet_size; i+=pixellength) {
x = packet[i ] | (packet[i+1]&0xF0)<<4;
y = (packet[i+1]&0x0F) | packet[i+2]<<4;
r = packet[i+3];
g = packet[i+4];
b = packet[i+5];
a = packet[i+6];
write_pixel_to_screen(x, y, r, g, b, a);
}
break;
// Protocol 4: xyrgb 12:12:3:3:2 specified for each pixel
case 4:
pixellength = 4;
packet_size = MIN(offset + (pixellength * MAX_PIXELS), packet_size);
for (i=offset; i<packet_size; i+=pixellength) {
x = packet[i ] | (packet[i+1]&0xF0)<<4;
y = (packet[i+1]&0x0F) | packet[i+2]<<4;
r = packet[i+3] & 0xE0;
g = packet[i+3]<<3 & 0xE0;
b = packet[i+3]<<6 & 0xC0;
a = 0xFF;
write_pixel_to_screen(x, y, r, g, b, a);
}
break;
// Protocol 5: xyrgba 12:12:2:2:2:2 specified for each pixel
case 5:
pixellength = 4;
packet_size = MIN(offset + (pixellength * MAX_PIXELS), packet_size);
for (i=offset; i<packet_size; i+=pixellength) {
x = packet[i ] | (packet[i+1]&0xF0)<<4;
y = (packet[i+1]&0x0F) | packet[i+2]<<4;
r = packet[i+3] & 0xC0;
g = packet[i+3]<<2 & 0xC0;
b = packet[i+3]<<4 & 0xC0;
a = packet[i+3]<<6 & 0xC0;
write_pixel_to_screen(x, y, r, g, b, a);
}
break;
// Error no recognied protocol defined
default:
break;
}
}
// Deinitialize screen buffer
deinit_frame_buffer();
return 0;
}
int main(int argc, char **argv){
int sockfd_fp, sockfd_data, connfd, udpfd, nready, maxfdp1, listenfd2;
char mesg[MAXLINE];
pid_t childpid, workerpid;
struct sockaddr_in servaddr, cliaddr;
fd_set rset;
const int on = 1;
int client_fds[FD_SETSIZE];
void sig_chld(int);
/* hash table init
* Contain all the fps, maybe should be a cache and read from disk
*/
hash_init(1024);
/*
* Create a bloom filter, the size NEED TO tradeoff
*/
filter = bloom_filter_new(5000);
if (!(fpfile_all = fopen("/tmp/fp.all.out", "w"))) {
fprintf(stderr, "E: Couldn't open file for write all fp\n");
fflush (stderr);
return;
}
/* Channel : fingerprint packet recv */
sockfd_fp = get_udp_socket(SERV_PORT+1);
int a = 65535;
Setsockopt(sockfd_fp, SOL_SOCKET, SO_RCVBUF, &a, sizeof(int));
Setsockopt(sockfd_fp, SOL_SOCKET, SO_SNDBUF, &a, sizeof(int));
/* Channel : other packet */
listenfd2 = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Setsockopt(listenfd2, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
Bind(listenfd2, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd2, LISTENQ);
// Channel to POX controller
bzero(&fakeaddr, sizeof(fakeaddr));
fakeaddr.sin_family = AF_INET;
fakeaddr.sin_port = htons(BLOOM_PORT);
Inet_pton(AF_INET, "10.0.0.1", &fakeaddr.sin_addr);
sockfdbloom = Socket(AF_INET, SOCK_DGRAM, 0);
Signal(SIGCHLD, sig_chld); /* must call waitpid() */
FD_ZERO(&rset);
maxfdp1 = max(sockfd_fp, listenfd2);
connfd = -1;
int i, maxi = -1;
for(i=0; i<FD_SETSIZE; i++)
client_fds[i] = -1;
for ( ; ; ) {
FD_SET(sockfd_fp, &rset);
FD_SET(listenfd2, &rset);
if ( (nready = select(maxfdp1 + 1, &rset, NULL, NULL, NULL)) < 0) {
if (errno == EINTR)
continue; /* back to for() */
else
err_sys("select error");
}
if (FD_ISSET(sockfd_fp, &rset)) {
recv_fp(sockfd_fp);
}
if (FD_ISSET(listenfd2, &rset)) {
int len = sizeof(cliaddr);
connfd = Accept(listenfd2, (SA *) &cliaddr, &len);
int a = 65535;
Setsockopt(connfd, SOL_SOCKET, SO_RCVBUF, &a, sizeof(int));
if ( (childpid = Fork()) == 0) { /* child process TO recv file data */
Close(listenfd2); /* close listening socket */
recv_chunk(connfd); // LOOP
exit(0);
}
Close(connfd); /* parent closes connected socket */
}
}
// cannot get here
}
int main(int argc, char **argv){
int res = 0;
struct timeval tv1, tv2;
char *directory = NULL;
if (argc != 3)
err_quit("usage: client <IPaddress> <file dir>");
serverip = argv[1];
directory = argv[2];
gettimeofday(&tv1, NULL);
sockfd4pox = get_udp_socket(QUICK_PORT);// channel with POX
bzero(&servaddrfp, sizeof(servaddrfp));
servaddrfp.sin_family = AF_INET;
servaddrfp.sin_port = htons(SERV_PORT+1);
Inet_pton(AF_INET, argv[1], &servaddrfp.sin_addr);
sockfd2serverfp = Socket(AF_INET, SOCK_DGRAM, 0);
// Connect(sockfd2serverfp, (SA *)&servaddrfp, sizeof(servaddrfp));
struct timeval tv;
tv.tv_sec = 1;
tv.tv_usec = 0;//
setsockopt(sockfd2serverfp, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
int a = 65535;
Setsockopt(sockfd2serverfp, SOL_SOCKET, SO_SNDBUF, &a, sizeof(int));
Setsockopt(sockfd2serverfp, SOL_SOCKET, SO_RCVBUF, &a, sizeof(int));
#ifdef USE_UDP
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
sockfd2server = Socket(AF_INET, SOCK_DGRAM, 0);
#else
sockfd2server = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT); //
Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
Connect(sockfd2server, (SA *) &servaddr, sizeof(servaddr));
Setsockopt(sockfd2server, SOL_SOCKET, SO_SNDBUF, &a, sizeof(int));
#endif
// start
start_backup();
uploadDir(directory);
// uploadDir_recur(directory);
gettimeofday(&tv2, NULL);
printf("Time cost = %lfms\n",(tv2.tv_sec-tv1.tv_sec)*1000.0+(tv2.tv_usec-tv1.tv_usec)/1000.0);
/* Upload complete, tell server to sync data to SDN controller
* Need a alg(by dedu ratio) to control this sync
*/
end_backup();
close(sockfd4pox);
// shutdown(sockfd2server, SHUT_WR);
// shutdown(sockfd2serverfp, SHUT_WR);
close(sockfd2serverfp);
close(sockfd2server);
exit(0);
}
int main(int argc, char *argv[])
{
struct sockaddr_in addr;
socklen_t addrlen;
mxbp_packet_t *block_packet;
char *group = NULL;
char *cp;
uint16_t port = DEFAULT_PORT;
int nbytes;
int epollfd;
int sock;
int ctlsock;
int c;
int rv;
int fd;
unsigned int no_sparse = 0;
int timeoutms = DEFAULT_TIMEOUT;
struct epoll_event ev;
struct epoll_event events[10];
progname = strdup(argv[0]);
while ((c = getopt(argc, argv, "g:p:f:s:t:o:nh")) != -1) {
switch (c) {
case 'g':
if (group) {
free(group);
}
group = strdup(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 't':
timeoutms = atoi(optarg);
break;
case 'f':
from_port = atoi(optarg);
break;
case 's':
if ((cp = strrchr(optarg, ':'))) {
*cp++ = 0;
server_port = atoi(cp);
}
server = strdup(optarg);
break;
case 'o':
if (outputname) {
free(outputname);
}
outputname = strdup(optarg);
break;
case 'n':
no_sparse = 1;
break;
default:
printf("Error: Unrecognized option -%c\n", c);
/* intentional fall through */
case 'h':
usage();
}
}
if (!group) {
group = DEFAULT_GROUP;
}
if (!server) {
server = DEFAULT_SERVER;
}
if (!from_port) {
srand(time(NULL));
from_port = (rand() % 32767) + 32767;
}
mapreq.magic = htobe32(MXBP_MAGIC);
mapreq.op = htobe16(MXBP_MAPREQ);
mapreq.size = 0;
mapreq.blockid = 0;
if ((ctlsock = get_udp_socket(server, from_port)) < 0) {
printf("Error:get_udp_socket(): failed.\n");
exit(EXIT_FAILURE);
}
if ((epollfd = epoll_create(10)) < 0) {
printf("%s:epoll_create(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = ctlsock;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, ctlsock, &ev) == -1) {
printf("%s:epoll_ctl(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
for (send_mapreq(ctlsock); !mapdesc.filesize;) {
rv = epoll_wait(epollfd, events, 10, timeoutms);
if (rv < 0) {
printf("%s:epoll_wait(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
if (rv) {
read_mapdesc(ctlsock);
} else {
/* Hit timeout, resend map request. */
send_mapreq(ctlsock);
}
}
close(epollfd);
if (!(blockmap = calloc(1, mapdesc.nblocks))) {
printf("Could not get %d bytes for block map: %s\n",
mapdesc.nblocks, strerror(errno));
exit(EXIT_FAILURE);
}
cp = strrchr(recvfilename, '/');
if (!cp) {
cp = recvfilename;
}
printf("Received description: File %s length %ld blocks %d\n", cp,
mapdesc.filesize, mapdesc.nblocks);
if (outputname) {
cp = outputname;
printf("Overriding output name with '%s'\n", cp);
}
/* There is no resume so we use O_TRUNC
* Note that we could periodically write out the blockmap
* and load that if present to be able to resume, but that's
* not a priority.
*/
if ((fd =
open(cp, O_WRONLY | O_CREAT | O_TRUNC | O_LARGEFILE, 0644)) < 0) {
printf("Could not open %s : %s\n", cp, strerror(errno));
exit(EXIT_FAILURE);
}
if (no_sparse) {
/* Cannot use a sparse file, so now create a big zeroed file. */
char zeros[MXBP_BLOCKSIZE];
int bcount;
memset(zeros, 0, sizeof(zeros));
for (bcount = 0; bcount <= mapdesc.nblocks; ++bcount) {
if (!write(fd, zeros, MXBP_BLOCKSIZE) != MXBP_BLOCKSIZE) {
printf("Failed to write block %d: %s (continuing anyway)\n", bcount, strerror(errno));
}
}
/* Rewind, just in case */
lseek(fd, 0, SEEK_SET);
}
if ((sock = get_multicast_socket(group, port)) < 0) {
printf("Could not get multicast socket.\n");
exit(EXIT_FAILURE);
}
if ((epollfd = epoll_create(10)) < 0) {
printf("%s:epoll_create(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = sock;
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sock, &ev) == -1) {
printf("%s:epoll_ctl(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
/* now just enter a read-print loop */
while (1) {
addrlen = sizeof(addr);
memset(msgbuf, 0, MAX_PACKET_SIZE);
rv = epoll_wait(epollfd, events, 10, timeoutms);
if (rv < 0) {
printf("%s:epoll_wait(): failed: %s\n", progname,
strerror(errno));
exit(EXIT_FAILURE);
}
if (rv) {
if ((nbytes =
recvfrom(sock, msgbuf,
sizeof(mxbp_header_t) + MXBP_BLOCKSIZE, 0,
(struct sockaddr *)&addr,
&addrlen)) < 0) {
printf("Failed to receive: %s",
strerror(errno));
exit(EXIT_FAILURE);
}
if (nbytes < sizeof(mxbp_header_t)) {
printf("Got short read, ignoring.\n");
continue;
}
block_packet = (mxbp_packet_t *) msgbuf;
block_packet->header.magic =
be32toh(block_packet->header.magic);
if (block_packet->header.magic != MXBP_MAGIC) {
printf("This is not an MXBP message.\n");
continue;
}
block_packet->header.op =
be16toh(block_packet->header.op);
if (block_packet->header.op != MXBP_BLOCK) {
printf("Unexpected operation %d, ignoring.\n",
block_packet->header.op);
continue;
}
block_packet->header.size =
be16toh(block_packet->header.size);
block_packet->header.blockid =
be32toh(block_packet->header.blockid);
if (block_packet->header.blockid > mapdesc.nblocks) {
printf
("Got Block ID %d past end of file %d, ignoring\n",
block_packet->header.blockid,
mapdesc.nblocks);
continue;
}
if (!blockmap[block_packet->header.blockid]) {
if (lseek64
(fd,
block_packet->header.blockid *
MXBP_BLOCKSIZE, SEEK_SET) && errno) {
printf
("Failed to seek to offset %d: %s\n",
block_packet->header.blockid *
MXBP_BLOCKSIZE, strerror(errno));
exit(EXIT_FAILURE);
}
if (write
(fd, block_packet->data,
block_packet->header.size) !=
block_packet->header.size) {
printf
("Failed to write to offset %d: %s\n",
block_packet->header.blockid *
MXBP_BLOCKSIZE, strerror(errno));
exit(EXIT_FAILURE);
}
blockmap[block_packet->header.blockid] = 1;
if (check_finished()) {
close(ctlsock);
close(sock);
close(epollfd);
close(fd);
printf("All done.\n");
exit(EXIT_SUCCESS);
}
}
} else {
/* Hit the poll timeout, so send a block request. */
send_block_req(ctlsock);
}
}
exit(EXIT_SUCCESS);
}
