static void send_message(struct packet_header *ph, char *datain, char **dataout)
{
char packet_str[128];
int sockfd;
struct sockaddr_un servaddr;
if ((sockfd = socket(AF_LOCAL, SOCK_STREAM, 0)) < 0)
err_sys("socket_error");
bzero(&servaddr, sizeof(servaddr));
servaddr.sun_family = AF_LOCAL;
strcpy(servaddr.sun_path, "/tmp/kodiext.socket");
if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
err_sys("connect_error");
//fprintf(stderr,"sent %s\n", packet_to_str(ph, packet_str));
Writen(sockfd, ph , sizeof(*ph));
Writen(sockfd, datain , ph->length);
Readn(sockfd, ph, sizeof(*ph));
if (ph->length > 0 && dataout != NULL)
{
*dataout = (char *) malloc(ph->length * sizeof(char) + 1);
Readn(sockfd, *dataout, ph->length);
*(*dataout + ph->length) = '\0';
}
//fprintf(stderr, "received %s\n", packet_to_str(ph, packet_str));
if (close(sockfd) < 0)
err_sys("close_error");
}
static int ReadCmd(int fd, char* buffer, int len)
{
uint8_t header[2];
int err = 0;
err = Readn(fd, header, 2);
printf("ReadCmd 1 err=%d\n", err);
if (err <= 0)
return err;
size_t cmdlen = header[1] << 8 | header[0];
printf("ReadCmd 2 cmdlen=%u\n", (uint32_t)cmdlen);
if (cmdlen>0) {
//assert(len > cmdlen);
err = Readn(fd, buffer, cmdlen);
if (err <= 0)
return err;
buffer[cmdlen-1]='\0';
printf("%s\n",buffer);
}
return err;
}
int32_t Recv_Len(int sockfd)//recv length first
{
int32_t temp;
int nread = Readn(sockfd, &temp, sizeof(int32_t));
if(nread == -1)
ERR_EXIT("Recv_Len");
else if(nread < sizeof(int32_t))
return 0;
return ntohl(temp);//mistake for ntohs
}
void home_page(const char *hostname,const char *filename){
int fd,i,n;
char buffer[MAXLINE];
fd = Tcp_connect(hostname,SERV);
snprintf(buffer,sizeof(buffer),GET_CMD,filename);
Writen(fd,buffer,sizeof(buffer);
while((n = Readn(fd,buffer,MAXLINE)) > 0)
printf("read %d bytes from %s\n",n,filename);
printf("end-of-file home page\n");
Close(fd);
}
static int mysocket_readn(mysocket* const me)
{
memset(me->buffer, 0, strlen(me->buffer));
if(me->len > MYSOCKET_BUFFER_SIZE)
{
return -3;
}
me->len = Readn(me->fd, me->buffer, me->len);
return me->len;
}
static int AutomaticStartDetection()
{
char buffer[1000];
char envnum[2];
int fd = open("/dev/mtd0", O_RDONLY);
lseek(fd,0xc0000+4,SEEK_SET );
ReadOneByte(fd, envnum);
lseek(fd,0x160000+4,SEEK_SET );
ReadOneByte(fd, envnum+1);
if(envnum[0] > envnum[1])
{
lseek(fd,0xc0000,SEEK_SET );
Readn(fd, buffer, 1000);
}
else
{
lseek(fd,0x160000,SEEK_SET );
Readn(fd, buffer, 1000);
}
int offset = StrMatch(buffer,"appauto=",1000);
if(offset == 0)
{
LOG_ERROR("not find appauto!");
PrintfRed("not find appauto!");
//return -2;
}
if(*(offset+buffer) != '1')
{
PrintfRed("appauto=%c",*(offset+buffer));
//return -1;
}
else
{
PrintfGreen("AutomaticStart");
}
close(fd);
return 0;
}
int CMonitorInfoObtainer::RecvResponse(SOCKET fd,ResponseMessageType* message)
{
int ret;
struct timeval tm;
//2.5s
tm.tv_sec=2;
tm.tv_usec=500*1000;
ret=Readn(fd,&message->code,sizeof(message->code),&tm);
if(ret < 0)
return ret;
ret=Readn(fd,&message->length,sizeof(message->length),&tm);
if(ret < 0)
return ret;
if(message->length)
{
message->InitContent(message->length);
ret=Readn(fd,message->pContent,message->length,&tm);
if(ret < 0)
return ret;
}
return 0;
}
void str_echo3(int sockfd)
{
ssize_t n;
struct args args;
struct result result;
for(;;){
if ((n = Readn(sockfd, &args, sizeof(args)) == 0)) {
return;
}
result.sum = args.arg1 + args.arg2;
Writen(sockfd, &result, sizeof(result));
}
}
int main(int argc, char *argv[])
{
if (argc != 6)
err_quit("Usage: %s <hostname or IPaddr> <port> <#children> "
"<#loop/child> <#bytes/request>", basename(argv[0]));
int nchildren = atoi(argv[3]);
int nloops = atoi(argv[4]);
int nbytes = atoi(argv[5]);
if (nbytes >= MAXN || nbytes <=0)
err_quit("nbytes = %d", nbytes);
char request[MAXLINE], reply[MAXN];
snprintf(request, sizeof(request), "%d\n", nbytes);
int i, j, fd;
size_t n, nw;
pid_t pid;
for (i = 0; i < nchildren; i++) {
if ((pid = fork()) < 0) err_sys("fork error");
if (pid == 0) { /* child */
for (j = 0; j < nloops; j++) {
fd = mode_connect(argv[1], argv[2], SOCK_STREAM);
if ((nw = write(fd, request, strlen(request))) != strlen(request))
err_sys("write error");
if ((n = Readn(fd, reply, nbytes)) != nbytes) {
struct sockaddr_in localaddr;
socklen_t addrlen = sizeof(struct sockaddr_in);
if (getsockname(fd, (struct sockaddr *)&localaddr, &addrlen) < 0)
err_sys("getsockname error");
err_quit("child (%d): server returned %d bytes: client port: %d (sent %zd bytes)",
i, n, ntohs(localaddr.sin_port), nw);
}
if (close(fd) < 0)
err_sys("close error");
}
printf("child %d done\n", i);
exit(0);
}
/* parent loops to fork() again */
}
while (wait(NULL) > 0)
;
if (errno != ECHILD)
err_sys("wait error");
exit(0);
}
void str_cli(FILE *fp, int sockfd) {
char sendline[MAXLINE];
struct args arg;
struct result result;
while(Fgets(sendline, MAXLINE, fp) != NULL) {
if(sscanf(sendline, "%ld%ld", &arg.arg1, &arg.arg2) != 2) {
printf("invalid input: %s", sendline);
continue;
}
Writen(sockfd, &arg, sizeof(arg));
if(Readn(sockfd, &result, sizeof(result)) == 0) {
err_quit("str_cli: server terminated prematurely");
}
printf("%ld\n", result.sum);
}
}
void XYTCPSocketLayer::ReadSocket()
{
while(_IsReadThreadRunning)
{
usleep(5000);
if(!_IsReadThreadRunning)
{
break;
}
char* pOut = new char[MAX_BYTE_READ_ONCE];
ssize_t readSize = Readn(_fd, pOut, MAX_BYTE_READ_ONCE);
if(readSize > 0)
{
//dispatch data
onReceive(pOut, readSize);
bzero(pOut, MAX_BYTE_READ_ONCE);
delete [] pOut;
}
else if(readSize == 0)
{
//dispatch disconnect
onDisconnect(XYNetworkErrorCode(XYNetworkErrorCode::eXYNetworkErrorCode::SERVER_DISCONNECT));
bzero(pOut, MAX_BYTE_READ_ONCE);
delete [] pOut;
_IsReadThreadRunning = false;
_stat = States_Disconnected;
break;
}
else
{
//dispatch read error
onError(XYNetworkErrorCode(XYNetworkErrorCode::eXYNetworkErrorCode::READ_ERROR));
bzero(pOut, MAX_BYTE_READ_ONCE);
delete [] pOut;
}
}
return;
}
int main(int argc, char** argv)
{
int i, j, fd, nchildren, nloops, nbytes;
pid_t pid;
ssize_t n;
char request[MAXLINE], reply[MAXN];
if (argc != 6)
err_quit(
"usage: client <hostname or IPaddr> <port> <#children> "
"<#loops/child> <#bytes/request>");
nchildren = atoi(argv[3]);
nloops = atoi(argv[4]);
nbytes = atoi(argv[5]);
snprintf(request, sizeof(request), "%d\n", nbytes); /* newline at end */
for (i = 0; i < nchildren; i++) {
if ((pid = Fork()) == 0) { /* child */
for (j = 0; j < nloops; j++) {
fd = Tcp_connect(argv[1], argv[2]);
Write(fd, request, strlen(request));
if ((n = Readn(fd, reply, nbytes)) != nbytes)
err_quit("server returned %d bytes", n);
Close(fd); /* TIME_WAIT on client, not server */
}
printf("child %d done\n", i);
exit(0);
}
/* parent loops around to fork() again */
}
while (wait(NULL) > 0) /* now parent waits for all children */
;
if (errno != ECHILD) err_sys("wait error");
exit(0);
}
uint32_t Recv(int sockfd, void* buf, uint32_t size)
{
int32_t len = Recv_Len(sockfd);
if(len == 0)
return 0;
else if(len > (int32_t)size)
{
fprintf(stderr, "bufsize is no enough");
exit(EXIT_FAILURE);
}
int32_t nread = Readn(sockfd, buf, len);
if(nread == -1)
ERR_EXIT("Recv");
else if((int32_t)nread < len)
{
return 0;
}
return len;
}
/**
* @brief Gestisce la lettura dei pacchetti UDP provenienti dall'Applicazione Mobile.
* @return void.
*/
void lettura_pkt_app(void)
{
uint32_t buf[PKTSIZE];
uint32_t idmsg;
/* ricevo un pkt */
/*ris=Readn(appmobilefd,(char*)buf,PKTSIZE);*/
ris=Readn(appmobilefd,(char*)buf,sizeof(buf));
if(ris!=sizeof(buf)) { fprintf(stderr,"recv from appmobile failed, received %d: ", ris); exit(9); }
idmsg = buf[0];
/*ris=send_udp(monitordatafd, (char*)buf, PKTSIZE , 1000, "127.0.0.1", cfgPorte[index] );*/
ris=send_udp(monitordatafd, (char*)buf, sizeof(buf) , 1000, "127.0.0.1", cfgPorte[index] );
if(!(ris))
{
fprintf(stderr,"pkt id %u NOT sent\n", idmsg );
}
/* Inserisce il pacchetto nella lista */
lPkt = ins_pkt(buf, lPkt, cfgPorte[index]);
}
/* Check and retrieve any new file on the server (pointed to by a connetion
* at socket 'soc') to directory 'directory'. Retrieve as long as the server
* acknowledges that there are no more new files.
* @Param: soc the socket at which the server is connected to.
* @Param: directory the directory where the file has to be retrieved to.
* @Return: void.
*/
void retrieve_new_files(int soc, char *directory){
struct sync_message empty_packet;
struct sync_message server_sync_packet;
int packet_size = sizeof(empty_packet);
int n;
int flag = 1; //A flag which is set to 1 as long as the server has some new files to send.
//Prepare an 'empty' packet, to check status of new files on the server.
strncpy(empty_packet.filename, "", MAXNAME);
empty_packet.mtime = 0;
empty_packet.size = 0;
while(flag){
//Write the empty packet.
Writen(soc, &empty_packet, packet_size);
//Read the server response.
if((n = Readn(soc, &server_sync_packet, packet_size)) != packet_size){
fprintf(stderr, "Communitation mismatch: Server did not acknowledge empty sync packet.\n");
Close(soc);
exit(1);
}
if(strlen(server_sync_packet.filename) == 0){
//No more new files left on the server.
printf("INFO: No more new files.\n");
flag = 0;
}else{
//Server has a new file, retrieve it.
printf("TX: Retrieving new file %s.\n", server_sync_packet.filename);
get_file(soc, directory, server_sync_packet.filename, server_sync_packet.size, server_sync_packet.mtime);
printf("\tTX complete: Retrieving new file %s.\n", server_sync_packet.filename);
}
}
}
void listener_task(int listen_port)
{
int listenfd = bind_listener(listen_port);
while (1) {
int connfd = Accept(listenfd, (SA *) NULL, NULL);
// TODO: Put message parsing in function
char msg_len_hex[4];
while (read(connfd, msg_len_hex, sizeof(msg_len_hex)) > 0) {
unsigned int msg_len = hex_to_int(msg_len_hex);
msg_len -= 5;
char *message = malloc(msg_len);
Readn(connfd, message, msg_len);
message[msg_len] = 0;
printf("%s\n", message);
free(message);
}
Close(connfd);
}
}
int main(int argc, char *argv[])
{
uint16_t portLBfixed;
int ris, LBfixedfd;
pthread_t th;
int primoricevuto=0;
int tipogenerazionepkt;
if(argc==1) {
printf ("uso i parametri di default \n%s\n", PARAMETRIDEFAULT );
portLBfixed = 11001;
tipogenerazionepkt=2;
}
else if(argc!=3) { printf ("necessari 2 parametri\n"); usage(); exit(1); }
else { /* leggo parametri da linea di comando */
portLBfixed = atoi(argv[1]);
tipogenerazionepkt=atoi(argv[2]);
}
if ((signal (SIGHUP, sig_close)) == SIG_ERR) { perror("signal (SIGHUP) failed: "); EExit(2); }
if ((signal (SIGINT, sig_close)) == SIG_ERR) { perror("signal (SIGINT) failed: "); EExit(2); }
if ((signal (SIGTERM, sig_close)) == SIG_ERR) { perror("signal (SIGTERM) failed: "); EExit(2); }
init_random();
ris=socketpair(AF_UNIX,SOCK_STREAM,0,fds);
if (ris < 0) { perror("socketpair fds0 failed: "); EExit(1); }
/*
ris=SetsockoptTCPNODELAY(fds[0],1); if (!ris) EExit(5);
ris=SetsockoptTCPNODELAY(fds[1],1); if (!ris) EExit(5);
*/
/* mi connetto al LBfixed */
ris=TCP_setup_connection(&LBfixedfd, "127.0.0.1", portLBfixed, 300000, 300000, 1);
if(!ris) { printf ("TCP_setup_connection() failed\n"); EExit(1); }
f=fopen("delayfixed.txt","wt");
if(f==NULL) { perror("fopen failed"); EExit(1); }
/* inizializzo il sistema di controllo dei pkt ricevuti e/o duplicati */
init_checkrecvFixed();
init_checkrecvFixedDelay();
FD_ZERO(&all);
FD_SET(LBfixedfd,&all);
maxfd=LBfixedfd;
FD_SET(fds[0],&all);
if(maxfd<fds[0]) maxfd=fds[0];
for(;;)
{
struct timeval timeout;
long int msecdelay;
do {
rdset=all;
timeout.tv_sec=10;
timeout.tv_usec=0;
ris=select(maxfd+1,&rdset,NULL,NULL,&timeout);
/* ris=select(maxfd+1,&rdset,NULL,NULL,&timeout); */
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("select failed: ");
EExit(1);
}
/* se arriva qualcosa dalla connessione TCP con LBfixed, leggo!!!! */
if( FD_ISSET(LBfixedfd,&rdset) )
{
uint32_t buf[PKTSIZE], idletto; int ris;
#ifdef VICDEBUG
fprintf(stderr,"in arrivo qualcosa dalla connessione TCP del LBfixed:\n");
#endif
/* ris=recv(LBfixedfd,(char*)buf,PKTSIZE,MSG_DONTWAIT); */
/* ris=Readn(LBfixedfd,(char*)buf,PKTSIZE); */
ris=Readn(LBfixedfd,(char*)buf,sizeof(buf));
/*if(ris!=PKTSIZE) { fprintf(stderr,"recv from LBfixed failed, received %d: ", ris); EExit(9); }*/
if(ris!=sizeof(buf)) { fprintf(stderr,"recv from LBfixed failed, received %d: ", ris); EExit(9); }
idletto=buf[0];
/* printf("ricevuto pkt id %u\n",idletto); */
msecdelay=compute_delay(buf);
if( check_pkt_recv_at_Fixed(idletto) == 1 ) /* pacchetto duplicato */
{
printf("ricevuto pkt duplicato id %d delay %ld msec \n",idletto, msecdelay);
numduplicati++;
}
else
{
/* memorizzo di avere ricevuto il pkt */
set_pkt_recv_at_Fixed(idletto);
SetpktrecvFixedDelay(idletto,msecdelay);
#ifdef OUTPUT_MEDIO
printf("ricevuto pkt id %lu delay %ld msec \n",idletto, msecdelay);
#endif
if(primoricevuto==0) {
pkt_generator_parameters params;
primoricevuto=1;
idlastrecv=idletto;
/* faccio partire il pthread pkt_generator per attivare la generazione di pacchetti */
params.tipogenerazionepkt=tipogenerazionepkt;
params.fd=fds[1];
ris = pthread_create (&th, NULL, pkt_generator, (void*)¶ms );
if (ris){
printf("ERROR; return code from pthread_create() is %d\n",ris);
EExit(-1);
}
}
else if(idletto>idlastrecv) {
idlastrecv=idletto;
}
if(msecdelay>150) {
numritardi++;
printf("%d : delay msec %ld TEMPO SUPERATO\n", idletto, msecdelay);
}
else {
numok++;
printf("%d : delay msec %ld\n", idletto, msecdelay);
}
/* save_delay(f,buf); */
}
}
else
{
if( FD_ISSET(fds[0],&rdset) )
{
char ch;
/* IL BUG E' QUI: E' STATO USATO UN VETTORE DI UINT32 PER CREARE IL PACCHETTO QUANDO SI SAREBBE DOVUTO USARE UN */
/* VETTORE DI CARATTERI (char buf[PKTSIZE]) DATO CHE : */
/* sizeof(buf) = 400 , con uint32_t buf[PKTSIZE] */
/* sizeof(buf) = 100 , con char buf[PKTSIZE] */
/* ERGO LA RICEZIONE E L'INVIO DEI PACCHETTI VA FATTA CON 400 DI DIMENSIONE E NON PKTSIZE, CIOÈ 100 */
uint32_t buf[PKTSIZE];
struct timeval sent;
do {
ris=recv(fds[0],&ch,1,0);
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("Appfixed - recv from scheduler failed: ");
sleep(1);
EExit(1);
}
/* spedisco i pkt */
/*memset((char*)buf,0,PKTSIZE);*/
memset((char*)buf,0,sizeof(buf));
buf[0]=idmsg;
gettimeofday(&sent,NULL);
memcpy( (char*)&(buf[1]), (char*)&sent, sizeof(struct timeval) );
/*
fprintf(stderr,"pkt %u sent %ld sec %ld usec\n", idmsg, sent.tv_sec, sent.tv_usec );
*/
/*ris=Sendn(LBfixedfd, (char*)buf, PKTSIZE );*/
ris=Sendn(LBfixedfd, (char*)buf, sizeof(buf) );
/*if(ris!=PKTSIZE) {*/
if(ris!=sizeof(buf)) {
fprintf(stderr,"Appfixed - Sendn failed ris %d TERMINO\n", ris);
sleep(1);
EExit(1);
}
#ifdef OUTPUT_MEDIO
fprintf(stderr,"pkt %u sent %dB\n", idmsg, ris);
#endif
idmsg++;
}
}
} /* fine for ;; */
return(0);
}
void *cp_copy_routine(void *_ctx)
{
int tid, fd, to;
ssize_t n, size;
off_t off;
void *buff;
cp_cntx_t *ctx = (cp_cntx_t *)_ctx;
tid = thread_pool_get_tidx(ctx->tpool);
if (posix_memalign(&buff, 4*KB, CP_SLOT_SIZE)) {
fprintf(stderr, "%s:[%d] errmsg:[%d] %s!\n", __FILE__, __LINE__, errno, strerror(errno));
pthread_exit((void *)-1);
return (void *)-1;
}
fd = Open(ctx->src, O_RDONLY|O_DIRECT, OPEN_MODE);
if (fd < 0) {
fprintf(stderr, "%s:[%d] errmsg:[%d] %s!\n", __FILE__, __LINE__, errno, strerror(errno));
pthread_exit((void *)-1);
return (void *)-1;
}
to = Open(ctx->dst, O_CREAT|O_RDWR|O_DIRECT, OPEN_MODE);
if (to < 0) {
fprintf(stderr, "%s:[%d] errmsg:[%d] %s!\n", __FILE__, __LINE__, errno, strerror(errno));
pthread_exit((void *)-1);
return (void *)-1;
}
off = tid * CP_SLOT_SIZE;
while (1) {
if (off > ctx->fst.st_size) {
break;
}
else if (off + CP_SLOT_SIZE > ctx->fst.st_size) {
size = ctx->fst.st_size - off;
}
else {
size = CP_SLOT_SIZE;
}
lseek(fd, off, SEEK_SET);
n = Readn(fd, buff, size);
if (n != size) {
fprintf(stderr, "%s:[%d] errmsg:[%d] %s!\n", __FILE__, __LINE__, errno, strerror(errno));
break;
}
lseek(to, off, SEEK_SET);
n = Writen(to, buff, size);
if (n != size) {
fprintf(stderr, "%s:[%d] errmsg:[%d] %s!\n", __FILE__, __LINE__, errno, strerror(errno));
break;
}
off += (ctx->tpool->num * CP_SLOT_SIZE);
}
CLOSE(fd);
CLOSE(to);
++ctx->complete;
if (ctx->complete == ctx->tpool->num) {
exit(0);
}
return (void *)0;
}
void
call_udpl_epoll(struct sockaddr_in servaddr, unsigned expected_size,
unsigned *latency, size_t sender_buf_size)
{
int sockfd;
char buf[BUF_SIZE];
struct timespec start;
struct timespec end;
int n, i;
size_t sent_size=0;
size_t max_send_size=0;
struct epoll_event ev, events[MAX_EVENTS];
int nfds, epollfd;
struct timespec wait_for_server={.tv_sec=0, .tv_nsec=INTERVAL};
assert(sender_buf_size <= BUF_SIZE);
nanosleep(&wait_for_server, NULL);
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (setNonblocking(sockfd) != 0) perror("setNonblocking");
epollfd = epoll_create(16);
if (epollfd == -1) {
perror("epoll_create");
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = sockfd;
// need not care about blocking
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev) == -1) {
perror("epoll_ctl: sockfd");
exit(EXIT_FAILURE);
}
max_send_size = MIN(MAX_UDP_SIZE, MIN(expected_size, sender_buf_size));
clock_gettime(CLOCK_MONOTONIC, &start);
// send something first
n = sendton(sockfd, buf, max_send_size, 0,
(struct sockaddr *)&servaddr, sizeof(servaddr));
if (n < 0)
perror("client sendto");
while (sent_size < expected_size) {
nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
if (nfds == -1) {
perror("epoll_pwait");
exit(EXIT_FAILURE);
}
for (i = 0; i < nfds; ++i) {
if (events[i].events & EPOLLIN) { // readable
n = Readn(events[i].data.fd, buf, BUF_SIZE);
sent_size += n; // only the echoed size is effective
if (DEBUG) printf("%u / %u<<<<%u / %u echo rate\n", n, MIN(max_send_size, expected_size - sent_size), sent_size, expected_size);
if (sendton(sockfd, buf, MIN(max_send_size, expected_size - sent_size), 0,
(struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
perror("client sendto");
}
}
}
clock_gettime(CLOCK_MONOTONIC, &end);
*latency = ((end.tv_sec - start.tv_sec) * 1000000000 +
end.tv_nsec - start.tv_nsec) / 2;
close(sockfd);
}
void
call_udpt_epoll(struct sockaddr_in servaddr, unsigned expected_size,
unsigned *latency, size_t sender_buf_size, size_t *received)
{
int sockfd;
char buf[BUF_SIZE];
struct timespec start;
struct timespec end;
int n, i, ret;
size_t sent_size=0;
size_t max_send_size, send_size;
struct epoll_event ev, events[MAX_EVENTS];
int nfds, epollfd;
struct timespec wait_for_server={.tv_sec=0, .tv_nsec=INTERVAL};
assert(sender_buf_size <= BUF_SIZE);
nanosleep(&wait_for_server, NULL);
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (setNonblocking(sockfd) != 0) perror("setNonblocking");
epollfd = epoll_create(16);
if (epollfd == -1) {
perror("epoll_create");
exit(EXIT_FAILURE);
}
ev.events = EPOLLIN;
ev.data.fd = sockfd;
// need not care about blocking
if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, &ev) == -1) {
perror("epoll_ctl: sockfd");
exit(EXIT_FAILURE);
}
max_send_size = MIN(MAX_UDP_SIZE, MIN(expected_size, sender_buf_size));
*received = 0;
clock_gettime(CLOCK_MONOTONIC, &start);
// when performing throughput, sender needs not to care about receiver
while (sent_size < expected_size) {
send_size = MIN(max_send_size, expected_size - sent_size);
Sendton(sockfd, buf, send_size, 0,
(struct sockaddr *)&servaddr, sizeof(servaddr));
if (DEBUG) printf("%u>>>>%u / %u sendto\n", send_size, sent_size, expected_size);
sent_size += send_size;
}
if (DEBUG) printf("client finished throughput sent %u\n", sent_size);
// the second while is used to receive multiple reply
while (1) {
nfds = epoll_wait(epollfd, events, MAX_EVENTS, EPOLL_MILLI_TIMEOUT);
if (nfds == -1) {
perror("epoll_pwait");
exit(EXIT_FAILURE);
} else if (nfds == 0)
break;
for (i = 0; i < nfds; ++i) {
if (events[i].events & EPOLLIN) { // readable
while (1) {
// since server will respond to every sent packet, there may be multiple responds
ret = read(events[i].data.fd, &n, sizeof(int));
if (ret < 0) {
if (!((errno == EAGAIN) || (errno == EWOULDBLOCK)))
perror("read error other than nonblock read");
break;
} else if (ret == 0) // end of file
break;
else {
// single "ack" response contributes a small amount of time
clock_gettime(CLOCK_MONOTONIC, &end);
*received += n;
if (DEBUG) printf("<<<<%u echoed\n", n);
}
}
if (DEBUG) printf("%i / %u ack Received\n", *received, expected_size);
}
}
}
*latency = (end.tv_sec - start.tv_sec) * 1000000000 +
end.tv_nsec - start.tv_nsec;
close(sockfd);
}
#ifdef CLIENT_MAIN
int main(int argc, char**argv)
{
struct sockaddr_in servaddr;
unsigned chunk_size[] = {4, 16, 64, 256, 1024, 4*1024, 16*1024, 64*1024, 256*1024, 512*1024, 32*1024, 48*1024, 96*1024, 128*1024};
//unsigned chunk_size[] = {4, 16, 64, 256, 1024, 4*1024, 16*1024, 32*1024, 64*1024, 96*1024, 128*1024};
unsigned latency, total_time;
size_t received;
int i;
int repeat=1;
size_t sender_buf_size=1024;
if (argc >= 5)
sender_buf_size = atoi(argv[4]);
if (argc >= 4)
repeat = atoi(argv[3]);
if (argc < 3) {
printf("usage: [udp|tcp] <IP address> <repeat times> <sender_buf_size=1024>\n");
exit(1);
}
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr=inet_addr(argv[2]);
servaddr.sin_port=htons(PORT);
while (repeat) {
if (strcmp(argv[1], "udp") == 0) {
printf("SIZE\tUDP latency us\tUDP througput MB/s\tLOST\tLOSS rate%%\n");
for (i=0; i<sizeof(chunk_size) / sizeof(chunk_size[0]); i++) {
call_udp(servaddr, 1, chunk_size[i], &latency, NULL);
call_udp(servaddr, 0, chunk_size[i], &total_time, &received);
printf("%8u\t%8u\t%8.2f\t%8u\t%8.2f\n", chunk_size[i], latency / 1000,
chunk_size[i] * 1000000000.0 / total_time / 1024 / 1024, chunk_size[i] - received,
(chunk_size[i] - received) * 100.0 / chunk_size[i]);
}
} else if (strcmp(argv[1], "udpl") == 0) {
printf("SIZE\tUDP latency us\tsender_buf_size: %i\n", sender_buf_size);
for (i=0; i<sizeof(chunk_size) / sizeof(chunk_size[0]); i++) {
call_udpl_epoll(servaddr, chunk_size[i], &latency, sender_buf_size);
printf("%8u\t%8u\n", chunk_size[i], latency / 1000);
}
} else if (strcmp(argv[1], "udpt") == 0) {
printf("SIZE\tUDP throughput MB/s\tLOST\tLOSS Rate%%\tsender_buf_size: %i\n", sender_buf_size);
for (i=0; i<sizeof(chunk_size) / sizeof(chunk_size[0]); i++) {
call_udpt_epoll(servaddr, chunk_size[i], &latency, sender_buf_size, &received);
printf("%8u\t%8.2f\t%8u\t%8.2f\n", chunk_size[i],
chunk_size[i] * 1000000000.0 / latency / 1024 / 1024,
chunk_size[i] - received,
(chunk_size[i] - received) * 100.0 / chunk_size[i]);
}
} else if (strcmp(argv[1], "tcp") == 0) {
printf("SIZE\tTCP latency us\tTCP througput MB/s\tLOST\tLOSS rate\n");
for (i=0; i<sizeof(chunk_size) / sizeof(chunk_size[0]); i++) {
call_tcp(servaddr, 1, chunk_size[i], &latency, NULL);
call_tcp(servaddr, 0, chunk_size[i], &total_time, &received);
printf("%8u\t%8u\t%8.2f\t%8u\t%8.2f\n", chunk_size[i], latency / 1000,
chunk_size[i] * 1000000000.0 / total_time / 1024 / 1024, chunk_size[i] - received,
(chunk_size[i] - received) * 100.0 / chunk_size[i]);
}
}
repeat--;
}
}
int createServer(Nest *nest, int dimension)
{
int listen_fd, conn_fd;
struct sockaddr_in cli_addr;
int cli_len;
char *recvline, str[INET_ADDRSTRLEN];
int dev_tag = -1, n;
int ret;
listen_fd = SocketListen(PORT);
if(listen_fd == -1)
{
fprintf(stderr, "SocketListen create failed\n");
return -1;
}
for(;;)
{
printf("\n\n\nServer is listening ... \n\n\n\n\n");
fprintf(stderr, "\n\n\nServer is listening ... \n\n\n\n\n");
cli_len = sizeof(cli_addr);
conn_fd = Accept(listen_fd, (struct sockaddr *)&cli_addr, &cli_len);
inet_ntop(AF_INET, &cli_addr.sin_addr, str, sizeof(str));
while(1)
{
#ifdef _DEBUG
printf("\n\n\nsocket from %s at PORT %d is connecting... \n", str, ntohs(cli_addr.sin_port));
#endif
recvline = (char *)malloc(sizeof(int));
memset(recvline, '\0', sizeof(int));
n = Readn(conn_fd, recvline, sizeof(int));
dev_tag = *(int *)recvline;
#ifdef _DEBUG
printf("createServer | dev_tag: %d\n", dev_tag);
#endif
switch(dev_tag)
{
case DEV_PC:
case DEV_PHONE:
ret = reponseWithDevice(nest, dimension, conn_fd, dev_tag);
if(ret == -1)
{
fprintf(stderr, "reponseWithDevice failed\n");
close(conn_fd);
}
else if(ret == -2)
{
fprintf(stderr, "reponseWithDevice ask to close the socket\n");
close(conn_fd);
}
fflush(stdout);
#ifdef _DEBUG
if(ret == 0)
{
printf("createServer | reponseWithDevice success\n");
fprintf(stderr, "createServer | reponseWithDevice success\n");
}
#endif
break;
case DEV_CLOSE:
close(conn_fd);
break;
default:
close(conn_fd);
printf("dev_tag default \n");
}
if( ((dev_tag != DEV_PC) && (dev_tag != DEV_PHONE)) || (ret == -1) || (ret == -2) )
{
printf("close current socket\n");
break;
}
}
}
free(recvline);
return 0;
}
/**
* @brief Main
* @return Ritorna un intero.
*/
int main(int argc, char *argv[])
{
/* Inizializzazione delle variabili */
index = 0;
lPkt = NULL;
contACK = 0;
tipoCnt = 0;
printf ("uso i parametri di default \n%s\n", PARAMETRIDEFAULT );
localportfrommobile = 6001;
localportdatamonitor = 7001;
portmonitor = 8000;
/* Inizializzazione dei vettori */
initV(cfgPKT);
initV(tipoConn);
initV(pktTipoConn);
init_random();
/* Si connette al monitor */
ris=TCP_setup_connection(&monitorfd, "127.0.0.1", portmonitor, 300000, 300000, 1);
if(!ris) { printf ("TCP_setup_connection() failed\n"); exit(1); }
else printf("monitorfd %d\n", monitorfd);
FD_ZERO(&all);
FD_SET(monitorfd,&all);
maxfd=monitorfd;
ris=RecvCfg(monitorfd,&numporte,porte);
if(!ris) { printf ("RecvCfg() failed\n"); exit(1); }
for(i=0;i<numporte;i++) {
cfgPorte[i]=porte[i];
}
/* Creazione del pacchetto della configurazione delle porte */
config_pkt_porte(cfgPKT, numporte);
ris=UDP_setup_socket_bound( &monitordatafd, localportdatamonitor, 65535, 65535 );
if (!ris) { printf ("UDP_setup_socket_bound() failed\n"); exit(1); }
FD_SET(monitordatafd,&all);
if(monitordatafd>maxfd)
maxfd=monitordatafd;
appmobilefd=0;
/* Attende la connessione dall'applicazione lato mobile */
ris=TCP_setup_socket_listening( &listening_mobilefd, localportfrommobile, 300000, 300000, 1);
if (!ris)
{ printf ("TCP_setup_socket_listening() failed\n");
exit(1);
}
do { memset (&Cli, 0, sizeof (Cli));
len = sizeof (Cli);
appmobilefd = accept ( listening_mobilefd, (struct sockaddr *) &Cli, &len);
} while ( (appmobilefd<0) && (errno==EINTR) );
if (appmobilefd < 0 ) {
perror("accept() failed: \n");
exit (1);
}
/* NO NAGLE per i tcp */
ris=SetsockoptTCPNODELAY(appmobilefd,1); if (!ris) { fprintf(stderr,"unable to setup TCPNODELAY option\n"); exit(5); }
/* chiusura del socket TCP listening e setup dei socket UDP */
close(listening_mobilefd);
FD_SET(appmobilefd,&all);
if(appmobilefd>maxfd)
maxfd=appmobilefd;
/* Imprime il timestamp sul primo pacchetto, ossia fa partire il cronometro */
gettimeofday(&timePktFirst,NULL);
memcpy( (char*)&(tipoConn[0]), (char*)&timePktFirst, sizeof(struct timeval) );
/* Controllo del tipo di connessione */
for(;;)
{
do
{
rdset=all;
#ifdef VICDEBUG
stampa_fd_set("rdset prima",&rdset);
#endif
ris=select(maxfd+1,&rdset,NULL,NULL,NULL);
} while( (ris<0) && (errno==EINTR) );
if(ris<0)
{
perror("select failed: ");
exit(1);
}
/* Controlla se sono arrivati pacchetti dall'applicazione */
if( FD_ISSET(appmobilefd,&rdset) )
{
uint32_t buf[PKTSIZE];
uint32_t idmsg;
struct timeval sent, now, tempoimpiegato;
long int msec;
/* riceve un pkt */
/*ris=Readn(appmobilefd,(char*)buf,PKTSIZE);
if(ris!=PKTSIZE) { fprintf(stderr,"recv from appmobile failed, received %d: ", ris); exit(9); }*/
ris=Readn(appmobilefd,(char*)buf,sizeof(buf));
if(ris!=sizeof(buf)) { fprintf(stderr,"recv from appmobile failed, received %d: ", ris); exit(9); }
/* Appena arriva un pacchetto dall'AppMobile, calcola quanto tempo è passato */
memcpy( (char*)&sent, (char*)&(tipoConn[0]), sizeof(struct timeval) );
gettimeofday(&now,NULL);
tempoimpiegato=differenza(now,sent);
msec=(tempoimpiegato.tv_sec*1000)+(tempoimpiegato.tv_usec/1000);
idmsg = buf[0];
/* ID del pkt di connessione è 42, tanto per cambiare */
pktTipoConn[0] = 42;
/* Può capitare che arrivi il primo pacchetto con 40msec di delay su connessione LENTA */
/* Se è il primo pacchetto */
if(idmsg < 1)
{
/* E se il primo pacchetto arriva con abbastanza ritardo, vuol dire che la connessione è LENTA */
if((msec > DELAY_VELOCE) && (msec < DELAY_MUTA))
{
tipoCnt = pktTipoConn[1] = CONN_LENTA;
break;
}
/* Altrimenti sarà MUTA */
else if(msec >= DELAY_MUTA)
{
tipoCnt = pktTipoConn[1] = CONN_MUTA;
break;
}
}
/* Se invece il secondo pacchetto è veloce, vuol dire che siamo nella VELOCE */
else if(msec <= DELAY_LENTA)
{
tipoCnt = pktTipoConn[1] = CONN_VELOCE;
break;
}
/* Altrimenti è LENTA */
else
{
tipoCnt = pktTipoConn[1] = CONN_LENTA;
break;
}
}
}
/* Invio il tipo di connessione al Fixed su tutte le porte attive per avvertirlo */
/* Invio il tipo di connessione su ogni porta attiva per ben due volte (per evitare di gestire i suoi NACK) */
for(k=0; k<2; k++)
{
for(i=0; i<numporte; i++)
{
ris = send_udp(monitordatafd, (char*)pktTipoConn, sizeof(pktTipoConn) , 1000, "127.0.0.1", cfgPorte[i]);
if(!(ris))
{
fprintf(stderr,"Errore durante l'invio del tipo di connessione!\n");
}
}
}
send_config(cfgPKT, monitordatafd, cfgPorte, numporte);
/* Configurazione del LBMobile sul tipo di connessione */
switch(tipoCnt)
{
case CONN_MUTA:
#ifdef TIPO_CONN
fprintf(stdout,ROSSO "\n*** Attivazione della connessione MUTA ***\n" DEFAULTCOLOR "\n");
#endif
/* *********************************************** MUTA ************************************************** */
for(;;)
{
do {
rdset=all;
#ifdef VICDEBUG
stampa_fd_set("rdset prima",&rdset);
#endif
ris=select(maxfd+1,&rdset,NULL,NULL,NULL);
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("select failed: ");
exit(1);
}
#ifdef VICDEBUG
stampa_fd_set("rdset dopo",&rdset);
#endif
/* Lettura dei pacchetti UDP provenienti dal Monitor */
if(FD_ISSET(monitordatafd,&rdset))
{
lettura_pkt_monitor();
}
/* Lettura dei pacchetti TCP (CONF, ACK, NACK) provenienti dal Monitor */
if( FD_ISSET(monitorfd,&rdset) )
{
char ch; int ris;
uint32_t tmpnumporte;
uint16_t tmpporte[MAXNUMCONNECTIONS];
uint32_t idmsg;
/* ris=recv(monitorfd,buf,65536,MSG_DONTWAIT); */
ris=recv(monitorfd,&ch,1,0);
if(ris!=1) { fprintf(stderr,"recv from monitor failed: "); exit(9); }
if(ch=='C')
{
/* Ricezione del nuovo numero di porte attive */
ris=recv(monitorfd,(char*)&tmpnumporte,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(C)recv_configurazione failed: "); exit(9); }
/* Ricezione del nuovo vettore di porte attive */
for(i=0;i<tmpnumporte;i++)
{
ris=recv(monitorfd,&(tmpporte[i]),sizeof(uint16_t),0);
if(ris!=sizeof(uint16_t)) { fprintf(stderr,"(C%d)recv_configurazione failed: ",i); exit(9); }
}
/* Aggiorna l'indice della porta a cui stava inviando i pacchetti col nuovo */
config_new_porte(cfgPorte, tmpporte);
setup_new_configurazione(&numporte,porte,&tmpnumporte,tmpporte);
/* Creazione del pacchetto della configurazione delle porte */
config_pkt_porte(cfgPKT, numporte);
/* Invio della configurazione al Fixed */
send_config(cfgPKT, monitordatafd, cfgPorte, numporte);
}
else if( ch=='A' )
{
ris=recv(monitorfd,(char*)&idmsg,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(A)recv ack failed: "); exit(9); }
/* Se arriva un ACK presente nella lista di pacchetti, lo rimuove */
if(find_id_pkt(idmsg, lPkt) != NULL)
{
lPkt = rim_pkt(idmsg, lPkt);
}
}
else if( ch=='N' )
{
struct listaPKT *list_aux;
list_aux = NULL;
ris=recv(monitorfd,(char*)&idmsg,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(N)recv nack failed: "); exit(9); }
/* Restituisce il puntatore lista all'elemento interessato */
list_aux = find_id_pkt(idmsg, lPkt);
/* Se il pacchetto NACKato è presente nella lista */
if(list_aux != NULL)
{
/* E se la porta da cui è stato inviato il pacchetto è uguale all'attuale da cui s'invia */
if(list_aux->portaPKT == cfgPorte[index])
{
/* Viene cambiata */
index=(index+1)%numporte;
}
/* Aggiorna anche la porta d'invio del pacchetto */
list_aux->portaPKT = cfgPorte[index];
/* Rispedisce l'esatto pacchetto che è stato NACKato */
ris=send_udp(monitordatafd, (char*)list_aux->pkt, sizeof(list_aux->pkt) , 1000, "127.0.0.1", cfgPorte[index] );
if(!(ris))
{
fprintf(stderr,"pkt id %u NOT sent\n", list_aux->pkt[0] );
}
}
}
}
/* Controlla se sono arrivati pacchetti dall'applicazione */
if( FD_ISSET(appmobilefd,&rdset) )
{
lettura_pkt_app();
}
} /* fine for ;; */
/***********************************************************************************************************/
break;
case CONN_VELOCE:
#ifdef TIPO_CONN
fprintf(stderr,GREEN "\n*** Attivazione della connessione VELOCE ***\n" DEFAULTCOLOR "\n");
#endif
/* *********************************************** VELOCE ************************************************** */
for(;;)
{
do {
rdset=all;
#ifdef VICDEBUG
stampa_fd_set("rdset prima",&rdset);
#endif
ris=select(maxfd+1,&rdset,NULL,NULL,NULL);
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("select failed: ");
exit(1);
}
#ifdef VICDEBUG
stampa_fd_set("rdset dopo",&rdset);
#endif
/* Lettura dei pacchetti UDP provenienti dal Monitor */
if(FD_ISSET(monitordatafd,&rdset))
{
lettura_pkt_monitor();
}
/* Lettura dei pacchetti TCP (CONF, ACK, NACK) provenienti dal Monitor */
if( FD_ISSET(monitorfd,&rdset) )
{
char ch; int ris;
uint32_t tmpnumporte;
uint16_t tmpporte[MAXNUMCONNECTIONS];
uint32_t idmsg;
/* ris=recv(monitorfd,buf,65536,MSG_DONTWAIT); */
ris=recv(monitorfd,&ch,1,0);
if(ris!=1) { fprintf(stderr,"recv from monitor failed: "); exit(9); }
if(ch=='C')
{
ris=recv(monitorfd,(char*)&tmpnumporte,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(C)recv_configurazione failed: "); exit(9); }
for(i=0;i<tmpnumporte;i++)
{
ris=recv(monitorfd,&(tmpporte[i]),sizeof(uint16_t),0);
if(ris!=sizeof(uint16_t)) { fprintf(stderr,"(C%d)recv_configurazione failed: ",i); exit(9); }
}
config_new_porte(cfgPorte, tmpporte);
setup_new_configurazione(&numporte,porte,&tmpnumporte,tmpporte);
/* Creazione del pacchetto della configurazione delle porte */
config_pkt_porte(cfgPKT, numporte);
send_config(cfgPKT, monitordatafd, cfgPorte, numporte);
}
else if( ch=='A' )
{
ris=recv(monitorfd,(char*)&idmsg,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(A)recv ack failed: "); exit(9); }
/* Se arriva un ACK presente nella lista di pacchetti, lo rimuove */
if(find_id_pkt(idmsg, lPkt) != NULL)
{
lPkt = rim_pkt(idmsg, lPkt);
}
/* Incrementa il contatore degli ACK */
contACK++;
}
else if( ch=='N' )
{
struct listaPKT *list_aux;
list_aux = NULL;
ris=recv(monitorfd,(char*)&idmsg,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(N)recv nack failed: "); exit(9); }
/* Restituisce il puntatore lista all'elemento interessato */
list_aux = find_id_pkt(idmsg, lPkt);
/* Se il pacchetto NACKato è presente nella lista */
if(list_aux != NULL)
{
/* Se precedentemente sono arrivati almeno due ACK dietro fila, vuol dire che attualmente il Mobile
è connesso sulla porta 'OK', quindi viene data una seconda chance al pacchetto rinviandolo sulla
medesima porta, altrimenti si scorre il vettore di porte dato che due NACK sulla stessa porta
indicano il cambiamento in 'LOSS' */
if(contACK < NUM_CONTACK)
{
if(list_aux->portaPKT == cfgPorte[index])
{
index=(index+1)%numporte;
}
}
else
{
contACK = 0;
}
/* Aggiorna anche la porta d'invio del pacchetto */
list_aux->portaPKT = cfgPorte[index];
/* Rispedisce l'esatto pacchetto che è stato NACKato */
ris=send_udp(monitordatafd, (char*)list_aux->pkt, sizeof(list_aux->pkt) , 1000, "127.0.0.1", cfgPorte[index] );
if(!(ris))
{
fprintf(stderr,"pkt id %u NOT sent\n", list_aux->pkt[0] );
}
}
}
}
/* Controlla se sono arrivati pacchetti dall'applicazione */
if( FD_ISSET(appmobilefd,&rdset) )
{
lettura_pkt_app();
}
} /* fine for ;; */
/***********************************************************************************************************/
break;
case CONN_LENTA:
#ifdef TIPO_CONN
fprintf(stdout,ORANGE "\n*** Attivazione della connessione LENTA ***\n" DEFAULTCOLOR "\n");
#endif
/* *********************************************** LENTA ************************************************** */
for(;;)
{
do {
rdset=all;
#ifdef VICDEBUG
stampa_fd_set("rdset prima",&rdset);
#endif
ris=select(maxfd+1,&rdset,NULL,NULL,NULL);
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("select failed: ");
exit(1);
}
#ifdef VICDEBUG
stampa_fd_set("rdset dopo",&rdset);
#endif
/* Lettura dei pacchetti UDP provenienti dal Monitor */
if(FD_ISSET(monitordatafd,&rdset))
{
lettura_pkt_monitor();
}
/* Lettura dei pacchetti TCP (CONF, ACK, NACK) provenienti dal Monitor */
if( FD_ISSET(monitorfd,&rdset) )
{
char ch; int ris;
uint32_t tmpnumporte;
uint16_t tmpporte[MAXNUMCONNECTIONS];
uint32_t idmsg;
/* ris=recv(monitorfd,buf,65536,MSG_DONTWAIT); */
ris=recv(monitorfd,&ch,1,0);
if(ris!=1) { fprintf(stderr,"recv from monitor failed: "); exit(9); }
if(ch=='C')
{
ris=recv(monitorfd,(char*)&tmpnumporte,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(C)recv_configurazione failed: "); exit(9); }
for(i=0;i<tmpnumporte;i++)
{
ris=recv(monitorfd,&(tmpporte[i]),sizeof(uint16_t),0);
if(ris!=sizeof(uint16_t)) { fprintf(stderr,"(C%d)recv_configurazione failed: ",i); exit(9); }
}
config_new_porte(cfgPorte, tmpporte);
setup_new_configurazione(&numporte,porte,&tmpnumporte,tmpporte);
/* Creazione del pacchetto della configurazione delle porte */
config_pkt_porte(cfgPKT, numporte);
send_config(cfgPKT, monitordatafd, cfgPorte, numporte);
}
else if( ch=='A' )
{
ris=recv(monitorfd,(char*)&idmsg,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(A)recv ack failed: "); exit(9); }
/* Se arriva un ACK presente nella lista di pacchetti, lo rimuove */
if(find_id_pkt(idmsg, lPkt) != NULL)
{
lPkt = rim_pkt(idmsg, lPkt);
}
}
else if( ch=='N' )
{
struct listaPKT *list_aux;
list_aux = NULL;
ris=recv(monitorfd,(char*)&idmsg,sizeof(uint32_t),0);
if(ris!=sizeof(uint32_t)) { fprintf(stderr,"(N)recv nack failed: "); exit(9); }
/* Restituisce il puntatore lista all'elemento interessato */
list_aux = find_id_pkt(idmsg, lPkt);
/* Se il pacchetto NACKato è presente nella lista */
if(list_aux != NULL)
{
/* Se non sono arrivati dei NACK precedentemente, viene data la seconda chance all'attuale pacchetto
NACKato, altrimenti si scorre il vettore di porte */
if(contACK > 0)
{
if(list_aux->portaPKT == cfgPorte[index])
{
index=(index+1)%numporte;
}
contACK = 0;
}
/* Aggiorna anche la porta d'invio del pacchetto */
list_aux->portaPKT = cfgPorte[index];
/* Rispedisce l'esatto pacchetto che è stato NACKato */
ris=send_udp(monitordatafd, (char*)list_aux->pkt, sizeof(list_aux->pkt) , 1000, "127.0.0.1", cfgPorte[index] );
if(!(ris))
{
fprintf(stderr,"pkt id %u NOT sent\n", list_aux->pkt[0] );
}
contACK++;
}
}
}
/* Controlla se sono arrivati pacchetti dall'applicazione */
if( FD_ISSET(appmobilefd,&rdset) )
{
lettura_pkt_app();
}
} /* fine for ;; */
/***********************************************************************************************************/
break;
default:
fprintf(stderr,"Errore durante la configurazione del tipo di connessione.\n");
exit(1);
break;
}
close(monitorfd);
return(0);
}
int main (int argc, char *argv[])
{
int tuttoOK=1;
short int local_port_number;
int listenfd[3], connectedfd[3], socketfd, ris, i, nwrite, nread, n;
struct sockaddr_in Cli;
int *intptr;
pthread_t thid[10];
/*pthread_attr_t attr;*/
unsigned int len;
char buflettura[LENVETLETTURA];
char bufscrittura[LENVETSCRITTURA];
int sum, sumlettura;
if ( (sizeof(int)!=sizeof(long int)) || (sizeof(int)!=4) )
{
printf ("dimensione di int e/o long int != 4 -> TERMINO\n");
fflush(stdout);
exit(1);
}
if (argc != 2)
{
printf ("necessario 1 parametro\n");
usage ();
exit (1);
}
else
{
local_port_number = atoi (argv[1]);
}
init_random();
if( ! Init_TCP_Session_Module(NULL) )
{
printf ("Init_TCP_Session_Module() failed\n");
fflush(stdout);
exit(1);
}
for(i=0;i<2;i++)
{
ris=TCPS_setup_socket_listening( listenfd+i, local_port_number+i);
if (!ris)
{
printf ("setup_socket_listening() failed\n");
exit(1);
}
}
ris=TCP_setup_socket_listening( listenfd+2, local_port_number+2);
if (!ris)
{
printf ("setup_socket_listening() failed\n");
exit(1);
}
/*sleep(50);*/
ris= TCP_setup_connection(&socketfd, "127.0.0.1", local_port_number+2);
if (!ris) {
printf ("impossibile connettersi al server: TERMINO!!\n" );
fflush(stdout);
exit(1);
}
/*
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
*/
for(i=0;i<3;i++)
{
intptr=malloc(sizeof(int));
if(intptr==NULL) { perror("malloc failed: "); fflush(stderr); exit(1); }
/* wait for connection request */
memset (&Cli, 0, sizeof (Cli));
len = sizeof (Cli);
for(;;)
{
printf ("Accept()\n");
*intptr = Accept (listenfd[i], (struct sockaddr *) &Cli, &len);
if (*intptr == SOCKET_ERROR)
{
if(errno==EINTR) continue;
else
{
printf ("Accept() failed, Err: %d \"%s\"\n", errno,
strerror (errno));
exit (1);
}
}
else
{
connectedfd[i]=*intptr;
/*printf("fd_accept server %d \n", connectedfd[i]);*/
/*ris=pthread_create(&(thid[i]), &attr, (ptr_thread_routine) &thread_For_Read_Write, (void *) intptr );*/
ris=pthread_create(&(thid[i]), NULL, (ptr_thread_routine) &thread_For_Read_Write, (void *) intptr );
if(ris)
{
/*
Close(*intptr);
Close(listenfd[i]);
free(intptr);
*/
fprintf (stdout, "pthread_create( For_Read_Write ) failed, Err: %d \"%s\"\n", errno,strerror(errno));
exit(2);
}
else
{
printf ("pthread_create succeed\n");
break;
}
} /* fine creazione threads */
} /* fine for(;;) */
} /* for(i=0;i<3;i++) */
for(i=0;i<2;i++)
{
ris=pthread_join( thid[i] , (void*) &intptr );
if(ris!=0){
printf("pthread_join( %d) failed: error=%d\n", i, ris );
exit(-1);
}
else
{
if(intptr==NULL)
{
printf("pthread failed: malloc error\n");
fflush(stdout);
tuttoOK=0;
exit(-1);
}
else if(*intptr==0)
{
printf("pthread failed: network error\n");
fflush(stdout);
tuttoOK=0;
exit(-1);
}
else
printf("pthread ok\n");
fflush(stdout);
}
}
/* parte client del socket tcp normale */
nread=sizeof(int);
/*printf("nread= %d", nread);*/
printf ("Readn() sum \n");
fflush (stdout);
n = Readn (socketfd, (char*) &(sum), nread);
if (n != nread)
{
printf ("Readn() sum failed \n");
fflush(stdout);
return (0);
}
sum=ntohl(sum);
/* scrittura sul socket tcp normale */
nwrite = LENVETSCRITTURA;
printf ("Writen()\n");
fflush (stdout);
n = Writen (socketfd, bufscrittura, nwrite );
if (n != nwrite)
{
printf ("Writen() failed \n");
fflush(stdout);
return (0);
}
/* lettura dal socket tcp normale*/
nread=LENVETLETTURA;
n = Readn (socketfd, buflettura, nread);
if (n != nread)
{
printf ("Readn() main failed \n");
fflush(stdout);
return (0);
}
sumlettura=sommavet(buflettura,LENVETLETTURA);
printf("somma spedita %d somma calcolata %d\n", sum, sumlettura );
fflush (stdout);
/*
stampavet(buflettura,LENVETLETTURA);
fflush (stdout);
*/
if(sumlettura!=sum)
{
printf ("\033[33;35;1m somma del tcp errata: errore in trasmissione dati\n \033[0m ");
fflush(stdout);
return (0);
}
/* fine parte client del socket tcp normale */
/* attesa thread che ha gestito il server con il socket tcp normale */
ris=pthread_join( thid[2] , (void*) &intptr );
if(ris!=0){
printf("pthread_join( 2) failed: error=%d\n", ris );
exit(-1);
}
else
{
if(intptr==NULL)
{
printf("pthread failed: malloc error\n");
tuttoOK=0;
}
else if(*intptr==0)
{
printf("pthread failed: network error\n");
tuttoOK=0;
}
else
printf("pthread ok\n");
fflush(stdout);
}
for(i=0;i<3;i++) {
Close (connectedfd[i]);
Close (listenfd[i]);
}
Close (socketfd);
printf ("Fine main\n");
if(tuttoOK==0)
{
printf ("\033[33;35;1m C'e' stato un errore di comunicazione\n \033[0m \n");
fflush(stdout);
exit(1);
}
if( ! Close_TCP_Session_Module(NULL) )
{
printf ("\033[33;35;1m Close_TCP_Session_Module() failed\n \033[0m ");
fflush(stdout);
exit(1);
}
printf ("Tutto OK\n");
fflush(stdout);
return (0);
}
int thread_For_Read_Write (int *psocketfd)
{
int newsocketfd;
int n, nread, nwrite;
char bufscrittura[LENVETLETTURA];
char buflettura[LENVETSCRITTURA];
int *ptr;
unsigned int sum;
newsocketfd=*psocketfd;
free(psocketfd);
psocketfd=NULL;
/* alloco la struttura in cui restituire il risultato */
ptr=malloc(sizeof(int));
if(ptr==NULL) {
perror("malloc failed: ");
fflush(stderr);
pthread_exit (NULL);
return(0);
}
sum=inizializza(bufscrittura,LENVETLETTURA);
printf("inizializza somma vettore %d\n", sum );
/*
stampavet(bufscrittura,LENVETLETTURA);
fflush (stdout);
*/
sum=htonl(sum);
/* scrittura della somma del vettore */
nwrite = sizeof(int);
printf ("Writen()\n");
fflush (stdout);
n = Writen (newsocketfd, (char*)&sum, nwrite );
if (n != nwrite)
{
printf ("Writen() sum failed");
fflush(stdout);
*ptr=0;
pthread_exit ( ptr ); /* valore restituito dal thread */
return (0);
}
/* lettura */
nread=LENVETSCRITTURA;
printf ("Readn() thread\n");
fflush (stdout);
n = Readn (newsocketfd, buflettura, nread);
/*printf("n di read thread %d", n);*/
if (n != nread)
{
printf ("Readn()thread failed \n");
fflush(stdout);
*ptr=0;
pthread_exit ( ptr ); /* valore restituito dal thread */
return (0);
}
/* scrittura */
nwrite = LENVETLETTURA;
printf ("Writen()\n");
fflush (stdout);
n = Writen (newsocketfd, bufscrittura, nwrite );
if (n != nwrite)
{
printf ("Writen() failed \n");
fflush(stdout);
*ptr=0;
pthread_exit ( ptr ); /* valore restituito dal thread */
return (0);
}
/* chiusura */
printf ("terminazione corretta del pthread\n");
fflush (stdout);
*ptr=1;
pthread_exit ( ptr ); /* valore restituito dal thread */
return (1);
}
/**
* struct sockaddr_in serv:
*
* Descriptions
**/
void
call_tcp(struct sockaddr_in servaddr, bool require_echo, unsigned expected_size,
unsigned *latency, size_t *received)
{
int sockfd;
char buf[BUF_SIZE];
struct timespec start;
struct timespec end;
int optval=1;
sockfd=socket(AF_INET,SOCK_STREAM,0);
if (setsockopt(sockfd, IPPROTO_IP, TCP_NODELAY, &optval, sizeof(optval)) != 0)
perror("setsockopt TCP_NODELAY");
if (connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
perror("connect");
struct timespec wait_for_server={.tv_sec=0, .tv_nsec=INTERVAL};
nanosleep(&wait_for_server, NULL);
Writen(sockfd, &expected_size, sizeof(unsigned));
Writen(sockfd, &require_echo, sizeof(bool));
// could ignore the header time
clock_gettime(CLOCK_MONOTONIC, &start);
Writen(sockfd, buf, expected_size);
if (DEBUG) printf("buf sent\n");
if (require_echo) {
// measuring latency
Readn(sockfd, buf, expected_size);
clock_gettime(CLOCK_MONOTONIC, &end);
*latency = ((end.tv_sec - start.tv_sec) * 1000000000 +
end.tv_nsec - start.tv_nsec) / 2;
} else {
// measuring througput
Readn(sockfd, received, sizeof(received));
clock_gettime(CLOCK_MONOTONIC, &end);
*latency = ((end.tv_sec - start.tv_sec) * 1000000000 +
end.tv_nsec - start.tv_nsec);
}
close(sockfd);
}
void
call_udp(struct sockaddr_in servaddr, bool require_echo, unsigned expected_size,
unsigned *latency, size_t *received)
{
int sockfd;
char buf[BUF_SIZE];
struct timespec start;
struct timespec end;
struct SimpleProtocol data;
data.require_echo = require_echo;
data.expected_size = expected_size;
sockfd=socket(AF_INET, SOCK_DGRAM, 0);
Sendton(sockfd, &data, sizeof(data), 0,
(struct sockaddr *)&servaddr, sizeof(servaddr));
clock_gettime(CLOCK_MONOTONIC, &start);
Sendton(sockfd, buf, expected_size, 0,
(struct sockaddr *)&servaddr, sizeof(servaddr));
if (DEBUG) printf("request sent: expected_size=%u, require_echo=%i, Reading...\n",
data.expected_size, data.require_echo);
if (data.require_echo) {
// measuring latency
// prevent client from blocking on receiving less data than expected
setNonblocking(sockfd);
Readn(sockfd, buf, expected_size);
clock_gettime(CLOCK_MONOTONIC, &end);
*latency = ((end.tv_sec - start.tv_sec) * 1000000000 +
end.tv_nsec - start.tv_nsec) / 2;
} else {
// measuring througput
Readn(sockfd, received, sizeof(int));
clock_gettime(CLOCK_MONOTONIC, &end);
*latency = ((end.tv_sec - start.tv_sec) * 1000000000 +
end.tv_nsec - start.tv_nsec);
if (DEBUG) printf("SUMMARY: %i of %u sent\n", *received, expected_size);
}
close(sockfd);
}
/*
int SVOsdSetAttr(int type,RGN_HANDLE handle,const MPP_CHN_S *pstChn,const RGN_CHN_ATTR_S *pstChnAttr)
{
int ret = FI_FAILED;
if(VI == type)
ret = SVOsdViSetAttr(handle,pstChn,pstChnAttr);
return ret;
}
int SVOsdGetAttr(int type,RGN_HANDLE handle,const MPP_CHN_S *pstChn,RGN_CHN_ATTR_S *pstChnAttr)
{
int ret = FI_FAILED;
if(VI == type)
ret = SVOsdViGetAttr(handle,pstChn,pstChnAttr);
return ret;
}
*/
int SVOsdInitFont(void)
{
int fd;
int ret = 0;
struct stat st;
unsigned int file_size = 0;
if(g_asc8x16Buf == NULL)
{
if ((fd = open(FONT_8EN_FILE ,O_RDONLY)) < 0)
{
ERRORPRINT("open(%s) error:%s\r\n",FONT_8EN_FILE,STRERROR_ERRNO);
return(-1);
}
if(fstat(fd, &st) != 0)
{
ERRORPRINT("fstat %s failed!\r\n",FONT_8EN_FILE);
close(fd);
return -1;
}
file_size = st.st_size;
if((g_asc8x16Buf = (unsigned char *)Calloc(1,file_size)) == NULL)
{
ERRORPRINT("g_asc8x16Buf Malloc \r\n");
close(fd);
return(-1);
}
ret = Readn(fd, (char *)g_asc8x16Buf, file_size);
if(-1 == ret)
{
ERRORPRINT("read() error:%s\r\n",STRERROR_ERRNO);
close(fd);
return(-1);
}
close(fd);
}
if(g_ch16x16Buf == NULL)
{
if ((fd = open(FONT_16CH_FILE, O_RDONLY)) < 0)
{
ERRORPRINT("open(%s) error:%s\r\n",FONT_16CH_FILE,STRERROR_ERRNO);
return(-1);
}
if(fstat(fd, &st) != 0)
{
ERRORPRINT("fstat %s failed!\r\n",FONT_16CH_FILE);
close(fd);
return -1;
}
file_size = st.st_size;
if ((g_ch16x16Buf = (unsigned char *)Calloc(1,file_size)) == NULL)
{
ERRORPRINT("g_asc_16x32_buf Malloc\r\n");
close(fd);
return(-1);
}
ret = Readn(fd, (char *)g_ch16x16Buf, file_size);
if(-1 == ret)
{
ERRORPRINT("read FONT_32CH_FILE\r\n");
close(fd);
return(-1);
}
close(fd);
}
return(0);
}
/* Synchronize the directory given by 'directory' with the server
* connected at the socket 'soc'. Send a file if it is more recent on the
* client. Retrieve a file if it is more recent on the server. Retrieve any
* new file on the server which does not already exist in the directory.
* Sleep execution for a predefined time and repeat the same as above.
* @Param: directroy the directory to synchronize.
* @Param: soc the socket at which the server is connected.
* @Return: void.
*/
void sync_files(char *directory, int soc){
DIR *dir;
struct dirent *file;
struct stat st;
char fullpath[CHUNKSIZE];
struct sync_message sync_packet;
struct sync_message server_sync_packet;
int packet_size = sizeof(sync_packet);
int file_count, n;
while(1){
file_count = 0; //Number of files in the directory.
if((dir = opendir(directory)) == NULL){
perror("Opening directory: ");
exit(1);
}
while(((file = readdir(dir)) != NULL) && file_count < MAXFILES){
//Grab the full path to the file.
strncpy(fullpath, directory, CHUNKSIZE);
strcat(fullpath, "/");
strncat(fullpath, file->d_name, CHUNKSIZE-strlen(fullpath));
if(stat(fullpath, &st) != 0){
perror("stat");
exit(1);
}
//Check if this file is a regular file (ignores dot files/subdirectories).
if(S_ISREG(st.st_mode)){
//Prepare the respective sync packet to be sent.
strncpy(sync_packet.filename, file->d_name, MAXNAME);
sync_packet.mtime = (long int)st.st_mtime;
sync_packet.size = (int)st.st_size;
//Write the sync packet to the server.
Writen(soc, &sync_packet, packet_size);
//Read the server's resposne to the sent sync packet.
if((n = Readn(soc, &server_sync_packet, packet_size)) != packet_size){
fprintf(stderr, "Communitation mismatch: Server did not acknowledge sync packet.\n");
Close(soc);
exit(1);
}
//Determine if this file has to be sycned either way.
if(server_sync_packet.mtime < sync_packet.mtime){ //Client has a newer version.
printf("TX: Sending file: %s\n", file->d_name);
send_file(soc, directory, sync_packet.filename);
printf("\tTX: Complete.\n");
}else if(server_sync_packet.mtime > sync_packet.mtime){ //Server has a more recent version.
printf("TX: Get file: %s\n", file->d_name);
get_file(soc, directory, server_sync_packet.filename, server_sync_packet.size, server_sync_packet.mtime);
printf("\tTX complete: Updating file %s.\n", server_sync_packet.filename);
}
}
file_count++;
}
if(closedir(dir) == -1){
perror("Closing directory: ");
exit(1);
}
/* Once all files in this directory have been checked for their synchronization,
* check if the server has any new files, which this client does not and retrieve
* them if so.
*/
retrieve_new_files(soc, directory);
printf("INFO: Sleeping\n");
//Sleep for WAITTIME.
sleep(WAITTIME);
}
Close(soc);
}
void recv_chunk(int sockfd){
ssize_t n, rlen;
char buf[MAXLINE];
char *res = "data recv done";
FILE *fs = NULL; // for store
int chunk_count = 0;
char fp[FP_LEN+1];
char filename[MAXLINE] = {0};
fp[FP_LEN] = '\0';
struct sockaddr_in cliaddr;
socklen_t cliaddrlen = sizeof(cliaddr);
memset(buf, 0, sizeof(buf));
TransferUnit *header = (TransferUnit *)malloc(sizeof(TransferUnit));
int headerlen = sizeof(TransferUnit);
printf("%d = headerlen\n", headerlen);
// recv the data chunk and store
while(1){
memset(header, 0, headerlen);
rlen = Readn(sockfd, header, headerlen);
// printf("header->type = %d, header->len = %d\n", header->type ,header->len);
if(rlen == 0 ){// No data now continue
// printf("%d===========\n", headerlen);
//printf("Client Closed!\n");
continue;
}
if(rlen != headerlen){
printf("Read Chunk Header Wrong!\n");
exit(-1);
}
if(header->type == 1){
rlen = Readn(sockfd, buf, header->len);
int flag = 0;
char *bufp = buf;
if(buf[0] == '#'){
flag = 1;
bufp ++;
n--;
}
memcpy(fp, bufp, FP_LEN);
memcpy(filename, bufp + FP_LEN, rlen - FP_LEN);
filename[rlen - FP_LEN] = '\0';
printf("File FP: %s, File name: %s\n", fp, filename);
if(flag){
update_fp(fp);
}
// index has been updated in recv_fp, so here just create file for store
char path[MAXLINE];
path[0] = '\0';
strcat(path, "store/");
strcat(path, fp);
printf("%s\n", path);
make_dir("store");
fs = fopen(path, "wb");
if(!fs){
printf("fopen error, %s\n", strerror(errno));
exit(-1);
}
}else if(header->type == 2){
rlen = Readn(sockfd, buf, header->len);
// 2. store this file and index
printf("**%d bytes recved and stored**\n", rlen);
fwrite(buf, sizeof(char), rlen, fs);
}else if(header->type == 3){
rlen = Readn(sockfd, buf, header->len);
printf("File EOF\n");
fflush(fs);
fclose(fs);
}else{
printf("Bad Type, header=%s \n", header);
}
memset(buf, 0, sizeof(buf));
}
close(sockfd);
}
int main(int argc, char *argv[])
{
uint16_t portLBmobile;
int ris, LBmobilefd;
pthread_t th;
int primoricevuto=0;
printf ("uso i parametri di default \n%s\n", PARAMETRIDEFAULT );
portLBmobile = 6001;
if ((signal (SIGHUP, sig_close)) == SIG_ERR) { perror("signal (SIGHUP) failed: "); EExit(2); }
if ((signal (SIGINT, sig_close)) == SIG_ERR) { perror("signal (SIGINT) failed: "); EExit(2); }
if ((signal (SIGTERM, sig_close)) == SIG_ERR) { perror("signal (SIGTERM) failed: "); EExit(2); }
init_random();
ris=socketpair(AF_UNIX,SOCK_STREAM,0,fds);
if (ris < 0) { perror("socketpair fds0 failed: "); EExit(1); }
/* mi connetto al LBmobile */
ris=TCP_setup_connection(&LBmobilefd, "127.0.0.1", portLBmobile, 300000, 300000, 1);
if(!ris) { printf ("TCP_setup_connection() failed\n"); EExit(1); }
f=fopen("delaymobile.txt","wt");
if(f==NULL) { perror("fopen failed"); EExit(1); }
FD_ZERO(&all);
FD_SET(LBmobilefd,&all);
maxfd=LBmobilefd;
FD_SET(fds[0],&all);
if(maxfd<fds[0]) maxfd=fds[0];
ris = pthread_create (&th, NULL, scheduler, NULL );
if (ris){
printf("ERROR; return code from pthread_create() is %d\n",ris);
EExit(-1);
}
for(;;)
{
struct timeval timeout;
do {
rdset=all;
timeout.tv_sec=10;
timeout.tv_usec=0;
ris=select(maxfd+1,&rdset,NULL,NULL,&timeout);
/* ris=select(maxfd+1,&rdset,NULL,NULL,&timeout); */
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("select failed: ");
EExit(1);
}
/* se arriva qualcosa dalla connessione TCP con LBmobile, leggo!!!! */
if( FD_ISSET(LBmobilefd,&rdset) )
{
uint32_t buf[PKTSIZE], idletto; int ris;
#ifdef VICDEBUG
fprintf(stderr,"in arrivo qualcosa dalla connessione TCP del LBmobile:\n");
#endif
/* ris=recv(LBmobilefd,(char*)buf,PKTSIZE,MSG_DONTWAIT); */
ris=Readn(LBmobilefd,(char*)buf,PKTSIZE);
if(ris!=PKTSIZE) { fprintf(stderr,"recv from LBmobile failed, received %d: ", ris); EExit(9); }
idletto=buf[0];
printf("ricevuto pkt id %u\n",idletto);
if(primoricevuto==0) {
primoricevuto=1;
idlastrecv=idletto;
numricevuti=1;
}
else if(idletto<=idlastrecv) {
fprintf(stderr,"ERRORE, RICEVUTO PKT FUORI ORDINE: letto %u precedente %u - TERMINO\n",idletto, idlastrecv);
EExit(999);
}
else {
if(idlastrecv+1 < idletto) {
numpersi += (idletto-(idlastrecv+1));
fprintf(stderr,"PERSO \n");
}
idlastrecv=idletto;
numricevuti++;
}
/* salvo delay pkt */
save_delay(f,buf);
}
else
{
if( FD_ISSET(fds[0],&rdset) )
{
char ch;
uint32_t buf[PKTSIZE];
struct timeval sent;
do {
ris=recv(fds[0],&ch,1,0);
} while( (ris<0) && (errno==EINTR) );
if(ris<0) {
perror("Appmobile - recv from scheduler failed: ");
sleep(1);
EExit(1);
}
/* spedisco i pkt */
memset((char*)buf,0,PKTSIZE);
buf[0]=idmsg;
gettimeofday(&sent,NULL);
memcpy( (char*)&(buf[1]), (char*)&sent, sizeof(struct timeval) );
ris=Sendn(LBmobilefd, (char*)buf, PKTSIZE );
if(ris!=PKTSIZE) {
fprintf(stderr,"Appmobile - Sendn failed ris %d TERMINO\n", ris);
sleep(1);
EExit(1);
}
fprintf(stderr,"pkt %u sent %dB\n", idmsg, ris);
idmsg++;
}
}
} /* fine for ;; */
return(0);
}
int main(int argc, char* argv[]) {
struct sockaddr_in sad; // structure to hold an IP address
struct addrinfo hint;
struct addrinfo *serverptr;
int sd; // socket descriptor
int port; // protocol port number
char *host; // pointer to host name
char buf[BUFSIZE]; // buffer for data from the server
char buf2[BUFSIZE];
int bytes_read; // number of bytes read from socket
int bytes_expected;
memset((char *)&sad,0,sizeof(sad)); // clear sockaddr structure
sad.sin_family = AF_INET; // set family to Internet
// Check command-line arguments
int i;
for(i = 0; i < BUFSIZE; i++) {
buf2[i] = 'A';
}
buf2[i-1] = 0;
if (argc < 3) {
printf("usage: getfile [ host ] [ port ]\n");
exit(-1);
}
host = argv[1];
port = atoi(argv[2]);
if (port <= 0) {
// test for legal value
// print error message and exit
fprintf(stderr,"SOURCE: bad port number %s\n",argv[2]);
exit(1);
}
// prepare the hint information
bzero(&hint, sizeof(hint));
hint.ai_flags = AI_CANONNAME;
hint.ai_family = AF_INET;
Getaddrinfo(host, NULL, &hint, &serverptr);
bcopy(serverptr->ai_addr, (char *)&sad, serverptr->ai_addrlen);
sad.sin_port = htons((u_short)port);
// Create a socket.
sd = Socket(AF_INET, SOCK_STREAM, 0);
// Connect the socket to the specified server.
Connect(sd, (struct sockaddr *)(&sad), sizeof(struct sockaddr));
// Repeatedly read data from socket and write to user's screen.
strcpy(buf, "here is a message for you");
bytes_expected = strlen(buf) + 1;
printf("SOURCE: Sending 'here is a message for you' \n");
Writen(sd, &bytes_expected, sizeof(int));
Writen(sd, buf, bytes_expected);
bytes_expected = strlen(buf2) + 1;
printf("SOURCE: Sending %d byte msg\n", bytes_expected);
printf("SOURCE: Sending '%s' byte msg\n", buf2);
Writen(sd, &bytes_expected, sizeof(int));
Writen(sd, buf2, bytes_expected);
bytes_read = Readn(sd, buf, sizeof(int));
printf("SOURCE: Expecting %d bytes from sink\n", bytes_read);
i = Readn(sd,buf,bytes_read);
printf("SOURCE: Got %d bytes from sink\n",i);
buf[i+1] = 0;
printf("SOURCE: Got '%s' from sink\n",buf);
// Close the socket.
Close(sd);
// Terminate the client program gracefully.
exit(0);
}
/* Retrieve a file 'file' of size 'size' by reading the contents of it from the
* socket 'sock' and write the file with the same name to directory 'directory'.
* Update the last modified time of this file to 'timestamp' on the filesystem.
* @Param: sock the socket to read from.
* @Param: directory the directory to write the file to.
* @Param: size the size of the file being retrieved.
* @Param: timestamp the last modified time to set to.
* @Return: void.
*/
void get_file(int sock, char* directory, char* file, int size, long int timestamp){
int readlength, readcount = 0, length;
char buffer[CHUNKSIZE];
char fullpath[CHUNKSIZE];
FILE *fp;
//Grab the full path to the file.
strncpy(fullpath, directory, CHUNKSIZE);
strcat(fullpath, "/");
strncat(fullpath, file, CHUNKSIZE-strlen(fullpath));
//Open the file. Overwite if it already exists.
if((fp = fopen(fullpath, "w")) == NULL) {
perror("fopen on get file: ");
exit(1);
}
/* Length computes the size of the file to be read per read call.
* if the length happens to be more than CHUNKSIZE (256) then read only
* CHUNKSIZE at max for now.
*/
if((length = size) > CHUNKSIZE){
length = CHUNKSIZE;
}
while( readcount < size ){
/* Compute the reamining length to be read. If the reamining length happens
* to be more than CHUNKSIZE (256) then read only CHUNKSIZE at max for now
*/
length = size - readcount;
if (length > CHUNKSIZE){
length = CHUNKSIZE;
}
readlength = Readn(sock, &buffer, length);
//Update how many bytes has been read yet.
readcount += readlength;
fwrite(buffer, readlength, 1, fp);
//If there was an error with fwrite.
if(ferror(fp)){
fprintf(stderr, "A write error occured.\n");
Close(sock);
exit(1);
}
}
if((fclose(fp))) {
perror("fclose: ");
exit(1);
}
struct stat sbuf;
struct utimbuf new_times;
if(stat(fullpath, &sbuf) != 0) {
perror("stat");
exit(1);
}
//Update the last modified time to 'timestamp' for this file on the filesystem.
new_times.actime = sbuf.st_atime; //Access time.
new_times.modtime = (time_t)timestamp;
if(utime(fullpath, &new_times) < 0) {
perror("utime");
exit(1);
}
}
