int main()
{
int sfd;
struct sockaddr_un serv_addr,client_addr;
int len=sizeof(client_addr);
serv_addr.sun_family=AF_UNIX;
strcpy(serv_addr.sun_path,"echo_socket");
sfd=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd,"socket error");
unlink(serv_addr.sun_path);
error_func(bind(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"bind error");
error_func(listen(sfd,5),"listen error");
int nfd=accept(sfd,(struct sockaddr*)&client_addr,&len);
error_func(nfd,"accept error");
char buffer[30];
recv(nfd,buffer,sizeof(buffer),0);
printf("%s\n",buffer);
send(nfd,"hello from server",30,0);
close(nfd);
close(sfd);
return 0;
}
int main()
{
int sfd;
struct sockaddr_in serv_addr,client_addr;
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(8000);
serv_addr.sin_addr.s_addr=INADDR_ANY;
int len=sizeof(client_addr);
sfd=socket(AF_INET,SOCK_STREAM,0);
error_func(sfd,"socket");
int val = 1;
int result=setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR, &val,sizeof(val)); if(result<0) printf("%s\n","sock\n");
error_func(bind(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"bind");
error_func(listen(sfd,4),"listen");
while(1)
{
int nfd=accept(sfd,(struct sockaddr*)&client_addr,&len);
int f=fork();
if(f==0)
{
//child process
dup2(nfd,0);
dup2(nfd,1);
execve("server1",NULL,NULL);
}
else
{
continue;
}
}
}
int init(urg_t *urg){
int error;
int i;
char *device = "/dev/ttyACM0";
//SERIAL PORT DETECTION
fprintf(stderr, "List of serial ports :\n");
int found_port_size = urg_serial_find_port();
if (found_port_size == 0) {
fprintf(stderr, "could not found serial ports.\n");
exit(EXIT_FAILURE);
}
for (i = 0; i < found_port_size; ++i) {
fprintf(stderr, "%s", (char *)urg_serial_port_name(i));
device = (char *)urg_serial_port_name(i);
}
fprintf(stderr, "\n");
fprintf(stderr, "Connection à %s\n", device);
error = urg_open(urg, URG_SERIAL, device, BAUDRATE);
if(error < 0){
error_func(urg, "connection failed");
}
else{
fprintf(stderr, "Connection établie à %s\n", device);
urg_set_scanning_parameter(urg, urg_rad2step(urg, ANGLE_MIN), urg_rad2step(urg, ANGLE_MAX), 0);//scan en continu, on ne garde que les point entre -PI/2 et PI/2
fprintf(stderr, "Parameters set\n");
error = urg_start_measurement(urg, URG_DISTANCE, URG_SCAN_INFINITY, 0);
if(error < 0){
error_func(urg, "failed to start measurement");
}
}
get_val(calc, 0, urg);//calcule les tables de cos/sin à l'avance
return error;
}
void fifoFunc()
{
error_func(mkfifo("fifo",0666),"making fifo server\n");
int fd=open("fifo",O_RDONLY|O_NONBLOCK);
error_func(fd,"opening file\n");
ffd=fd;
FD_SET(ffd,&readset);
}
static int QSI_STATUS (int OK)
{
/* Prints QSI error message and returns FALSE if OK == FALSE */
char c[80];
if (OK) {
error_func ((int *) 0, QSI_func, c);
return TRUE;
} else {
QSICamera_get_LastError (c);
error_func ((int *) 1, QSI_func, c);
return FALSE;
}
}
int main()
{
int usfd;
struct sockaddr_in serv_addr,client_addr;
int len=sizeof(client_addr);
serv_addr.sin_family=PF_INET;
serv_addr.sin_port=htons(8000);
serv_addr.sin_addr.s_addr=INADDR_ANY;
usfd=socket(PF_INET,SOCK_DGRAM,0);
error_func(usfd,"socket");
error_func(bind(usfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"bind");
char buffer[30];
printf("%s\n","check1");
recvfrom(usfd,buffer,sizeof(buffer),0,(struct sockaddr*)&client_addr,&len);
printf("%s\n",buffer);
sendto(usfd,"hai from server",30,0,(struct sockaddr*)&client_addr,len);
return 0;
}
void pipeFunc()
{
int fd[2];
error_func(pipe(fd),"Creating the pipe\n");
int c=fork();
error_func(c,"forking the process\n");
if(c==0)
{
//child process
close(fd[0]);
//write(fd[1],"From Child Pipe",30);
exit(0);
}
else
{
//parent process
close(fd[1]);
pfd=fd[0];
FD_SET(pfd,&readset);
}
}
static void
handle_error(const char *format, ...)
{
va_list ap;
va_start(ap, format);
if (error_func != NULL) {
error_func(format, ap);
}
va_end(ap);
}
int main()
{
rsfd = socket(AF_INET, SOCK_RAW, 100);
error_func(rsfd, "Failed to create raw socket");
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
int to_send = 0;
char *msg = (char *)malloc(sizeof(char)*100);
while(1){
printf("%s\n", "Waiting to receive message");
int s = recvfrom(rsfd, msg, 100, 0 , (struct sockaddr *)&client_addr, &client_len);
error_func(s, "Failed to receive");
printf("%s\n",msg);
fflush(stdout);
memset(msg, 0 , sizeof(msg));
}
}
int main(int argc,char * argv[])
{
int i;
printf("%d\n",argc);
for(i=0;i<argc-1;i++)
{
char file[50];
memset(file,0,50);
strcat(file,argv[i+1]);
strcat(file,"B");
error_func(mkfifo(file,0666),"making fifo server\n");
fdA[i]=open(file,O_RDONLY|O_NONBLOCK);
error_func(fdA[i],"opening file1\n");
}
struct pollfd fdp[argc-1];
for(i=0;i<argc-1;i++)
{
fdp[i].fd=fdA[i];
fdp[i].events=POLLRDNORM;
}
int j;
while(1)
{
error_func(poll(fdp,argc-1,100),"poll error");
for(i=0;i<argc-1;i++)
{
if(fdp[i].revents & fdp[i].events)
{
read(fdA[i],readbuf,sizeof(readbuf));
fprintf(stdout,"%s\n",readbuf);
memset(readbuf,0,sizeof(readbuf));
}
}
}
return 0;
}
void i2cman_handler()
{
ROM_I2CMasterIntClear(I2C_PORT);
if(current_op == end || current_op == 0)
return; // do absolutely nothing (irq may be called after aborting)
uint32_t error = finish_op(current_op);
if(error != I2C_MASTER_ERR_NONE)
{
stop();
if(error & I2C_MASTER_ERR_ARB_LOST)
{
if(error_func)
error_func(I2C_ARBLOST);
}
else
{
// error, abort completely
//kill_op(current_op);
// bad bad bad!
if(error_func)
error_func(I2C_NOACK);
}
return;
}
current_op ++;
if(current_op == end)
{
stop(); // all done
if(success_func)
success_func();
return;
}
// otherwise, process the next op
start_op(current_op);
}
int main()
{
server_init();
int sfd,nfd;
struct sockaddr_in serv_addr,client_addr;
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(6000);
serv_addr.sin_addr.s_addr=INADDR_ANY;
int len=sizeof(client_addr);
sfd=socket(AF_INET,SOCK_STREAM,0);
error_func(sfd,"socket");
int set = setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof(int));
int main(int argc,char*argv[])
{
int sfd;
struct sockaddr_in serv_addr;
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(8000);
serv_addr.sin_addr.s_addr=INADDR_ANY;
sfd=socket(AF_INET,SOCK_STREAM,0);
connect(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
send(sfd,argv[1],sizeof(argv[1]),0);
char portbuffer[10];
recv(sfd,portbuffer,sizeof(portbuffer),0);
int port=atoi(portbuffer);
printf("%d\n",port);
//sleep(5);
int csfd=socket(AF_INET,SOCK_STREAM,0);
serv_addr.sin_port=htons(port);
connect(csfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
while(1)
{
printf("%s\n","connection9" );
error_func(send(csfd,"from client to server",30,0),"sending error");
printf("%s\n","connection3" );
char printbuffer[30];
sleep(3);
printf("%s\n","connection4" );
error_func(recv(csfd,printbuffer,sizeof(printbuffer),0),"recv error");
printf("%s\n","connection5" );
printf("%s\n",printbuffer);
printf("%s\n","connection2" );
}
}
int main()
{
int sfd;
struct sockaddr_un serv_addr;
serv_addr.sun_family=AF_UNIX;
strcpy(serv_addr.sun_path,"main_echo_socket");
sfd=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd,"socket error");
error_func(connect(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"connect error");
char buffer[30];
send(sfd,"From client to mainserver",30,0);
while(1)
{
recv(sfd,buffer,30,0);
printf("client :%s\n",buffer);
send(sfd,"from client to server",30,0);
}
close(sfd);
return 0;
}
int main()
{
int nfd;
struct sockaddr_in serv_addr,client_addr;
socklen_t len=sizeof(client_addr);
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(8000);
serv_addr.sin_addr.s_addr=INADDR_ANY;
nfd=socket(AF_INET,SOCK_STREAM,0);
error_func(nfd,"socket call");
error_func(connect(nfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"connect call");
perror("connect :");
send(nfd,"8001",10,0);
//getsockname
struct sockaddr_storage addr;
char ipstr[INET6_ADDRSTRLEN];
socklen_t len1=sizeof(addr);
getsockname(nfd,(struct sockaddr*)&addr,&len1);
struct sockaddr_in *s = (struct sockaddr_in *)&addr;
int port=ntohs(s->sin_port);
inet_ntop(AF_INET, &s->sin_addr, ipstr, sizeof (ipstr));
printf("%s%d\n","The port is",ntohs(s->sin_port));
printf("Peer IP address: %s\n", ipstr);
//
nfd=socket(AF_INET,SOCK_STREAM,0);
error_func(nfd,"socket call");
serv_addr.sin_port=htons(8001);
int set = setsockopt(nfd, SOL_SOCKET, SO_REUSEPORT, &(int){ 1 }, sizeof(int));
int main(int argc ,char * argv[])
{
int port=9002;
int sfd,nfd;
struct sockaddr_in serv_addr,client_addr;
socklen_t len;
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(port);
serv_addr.sin_addr.s_addr=INADDR_ANY;
sfd=socket(AF_INET,SOCK_STREAM,0);
error_func(sfd,"error in socket call");
int set = setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &(int){ 1 }, sizeof(int));
int main()
{
//get pid of backupserver
int shmid;
key_t key;
int *shm, *s;
key = 5678;
shmid = shmget(key, sizeof(int), 0666);
shm = (int*) shmat(shmid, NULL, SHM_RND);
s=shm;
pid=*s;
int i=0;
for(i=0;i<max_clients;i++)
{
cfd[i]=-1;
}
signal(SIGUSR1,handler_func); //send sigusr1 to shutdown the server
printf("Process id:%d\n",getpid());
struct sockaddr_un serv_addrs;
serv_addrs.sun_family=AF_UNIX;
strcpy(serv_addrs.sun_path,"back_echo_socket");
bsfd=socket(AF_UNIX,SOCK_STREAM,0);
error_func(bsfd,"socket error");
error_func(connect(bsfd,(struct sockaddr*)&serv_addrs,sizeof(serv_addrs)),"connect error");
char buffer[30];
send(bsfd,"From server to backupserver",30,0);
int sfd;
struct sockaddr_un serv_addr,client_addr;
int len=sizeof(client_addr);
serv_addr.sun_family=AF_UNIX;
strcpy(serv_addr.sun_path,"echo_socket");
sfd=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd,"socket error");
unlink(serv_addr.sun_path);
error_func(bind(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"bind error");
error_func(listen(sfd,5),"listen error");
while(1)
{
printf("%s\n","came1");
int nfd=accept(sfd,(struct sockaddr*)&client_addr,&len);
printf("%s\n","came2");
error_func(nfd,"accept error");
cfd[clients_no++]=nfd;
printf("%s\n","client accepted");
pthread_create(&threads[clients_no],NULL,func,(void *)(&nfd));
}
}
int main()
{
int sfd,sfd1;
struct sockaddr_un serv_addr,client_addr;
struct sockaddr_un serv_addrs;
int len=sizeof(client_addr);
serv_addr.sun_family=AF_UNIX;
strcpy(serv_addr.sun_path,"echo_socket_c");
serv_addrs.sun_family=AF_UNIX;
strcpy(serv_addrs.sun_path,"echo_socket_cs");
sfd1=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd1,"socket error");
error_func(connect(sfd1,(struct sockaddr*)&serv_addrs,sizeof(serv_addrs)),"connect error");
send(sfd1,"From server c to server s",30,0);
sfd=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd,"socket error");
unlink(serv_addr.sun_path);
error_func(bind(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"bind error");
error_func(listen(sfd,5),"listen error");
char buffer[30];
int nfd=accept(sfd,(struct sockaddr*)&client_addr,&len);
error_func(nfd,"accept error");
recv(nfd,buffer,sizeof(buffer),0);
printf("%s\n",buffer);
int clients_no=0;
while(1)
{
int fd=recv_file_descriptor(nfd);
printf("File descriptor%d\n",fd);
if(clients_no>=max_clients)
{
printf("%s\n","max reached of server c");
send_file_descriptor(sfd1,fd);
}
else
pthread_create(&threads[clients_no++],NULL,func,(void *)(&fd));
}
}
int main(int argc, char const *argv[])
{
struct sockaddr_in addr;
int rsfd, n, len, val=1;
char buffer[BUFSIZE], buf[128];
rsfd = socket(AF_INET, SOCK_RAW, 101);
error_func(rsfd,"socket");
setsockopt(rsfd, IPPROTO_IP, IP_HDRINCL, &val, sizeof(val));
memset((char *)&addr, 0, sizeof addr);
addr.sin_family = AF_INET;
addr.sin_port = 0;
addr.sin_addr.s_addr = INADDR_ANY;
struct iphdr * iph;
memset(buf, 0, 128);
printf("Enter Message:");
scanf("%s", buf);
memset(buffer, 0 , BUFSIZE);
iph = (struct iphdr *)buffer;
iph->version = 4;
iph->ihl = 5;
iph->tos = 0;
iph->frag_off = 0;
iph->ttl = 8;
iph->protocol = 101;
iph->saddr = inet_addr("127.0.1.1");
iph->daddr = inet_addr("127.0.0.1");
strcpy(buffer+sizeof(struct iphdr), buf);
iph->tot_len = htons(sizeof(struct iphdr)+strlen(buf));
if(sendto(rsfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&addr, sizeof addr) < 0)
{
perror("sendto() ");
}
return 0;
}
int main()
{
int train_fd[3];
int i,j,k,flag;
//signals
int shmid;
key_t key;
int pid,available_no;
int *shm,*s;
for(i=0;i<3;i++)
{
plat_available[i]=1; //initially all are available
}
//arranging for signals
pid = getpid();
key = 5678;
shmid = shmget(key, 2*sizeof(int), IPC_CREAT | 0666);
shm = shmat(shmid, NULL, SHM_RND);
s=shm;
*s++=pid; *s=-1;
signal(SIGUSR1,handler_func);
for(i=0;i<3;i++) //opening the file descriptors for trains
{
char namebuffer[10];
sprintf(namebuffer,"%s%d","platform",i+1);
mkfifo(namebuffer,0666);
train_fd[i]=open(namebuffer,O_RDONLY|O_NONBLOCK);
error_func(train_fd[i],"opening the fifo file");
}
struct pollfd fd_train[3]; //poll onn train fd's
for(i=0;i<3;i++)
{
fd_train[i].fd=train_fd[i];
fd_train[i].events=POLLRDNORM;
}
while(1)
{
error_func(poll(fd_train,3,100),"error while polling\n");
for(i=0;i<3;i++)
{
if(POLLRDNORM & fd_train[i].revents)
{
char buffer[15];
read(train_fd[i],buffer,sizeof(buffer));
flag=0;
for(j=0;j<3;j++)
{
if(plat_available[j]==1)
{
flag=1;
break;
}
}
if(flag) //j platform is available
{
char trainnamebuffer[15];
sprintf(trainnamebuffer,"%s%d","train",i+1);
broadcast_plat(trainnamebuffer); //broadcast to all platforms arrvial of train i
char platnamebuffer[15];
sprintf(platnamebuffer,"%s%d","plat",j+1);
int train_acceptfd=open(trainnamebuffer,O_WRONLY);
write(train_acceptfd,platnamebuffer,sizeof(platnamebuffer)); //telling train which platform is available
}
else
{
//no platfrom is available
}
}
}
}
}
Validator* parse_schema_n(char const *str, size_t len,
UriResolver *uri_resolver, char const *root_scope,
JschemaErrorFunc error_func, void *error_ctxt)
{
//JsonSchemaParserTrace(stdout, ">>> ");
void *parser = JsonSchemaParserAlloc(malloc);
YajlContext yajl_context =
{
.parser = parser,
.parser_ctxt = {
.validator = NULL,
.error = SEC_OK,
},
};
const bool allow_comments = true;
#if YAJL_VERSION < 20000
yajl_parser_config yajl_opts =
{
allow_comments,
0,
};
yajl_handle yh = yajl_alloc(&callbacks, &yajl_opts, NULL, &yajl_context);
#else
yajl_handle yh = yajl_alloc(&callbacks, NULL, &yajl_context);
yajl_config(yh, yajl_allow_comments, allow_comments ? 1 : 0);
yajl_config(yh, yajl_dont_validate_strings, 1);
#endif // YAJL_VERSION
if (!yh)
{
JsonSchemaParserFree(parser, free);
return NULL;
}
if (yajl_status_ok != yajl_parse(yh, (const unsigned char *)str, len))
{
if (yajl_context.parser_ctxt.error == SEC_OK)
{
unsigned char *err = yajl_get_error(yh, 0/*verbose*/, (const unsigned char *)str, len);
if (error_func)
error_func(yajl_get_bytes_consumed(yh), SEC_SYNTAX, (const char *) err, error_ctxt);
yajl_free_error(yh, err);
}
else
{
if (error_func)
error_func(yajl_get_bytes_consumed(yh), yajl_context.parser_ctxt.error,
SchemaGetErrorMessage(yajl_context.parser_ctxt.error), error_ctxt);
}
yajl_free(yh);
JsonSchemaParserFree(parser, free);
return NULL;
}
#if YAJL_VERSION < 20000
if (yajl_status_ok != yajl_parse_complete(yh))
#else
if (yajl_status_ok != yajl_complete_parse(yh))
#endif
{
if (yajl_context.parser_ctxt.error == SEC_OK)
{
unsigned char *err = yajl_get_error(yh, 0, (const unsigned char *)str, len);
if (error_func)
error_func(yajl_get_bytes_consumed(yh), SEC_SYNTAX, (const char *) err, error_ctxt);
yajl_free_error(yh, err);
}
else
{
if (error_func)
error_func(yajl_get_bytes_consumed(yh), yajl_context.parser_ctxt.error,
SchemaGetErrorMessage(yajl_context.parser_ctxt.error), error_ctxt);
}
yajl_free(yh);
JsonSchemaParserFree(parser, free);
return NULL;
}
// Let the parser finish its job.
static TokenParam token_param;
JsonSchemaParser(parser, 0, token_param, &yajl_context.parser_ctxt);
// Even if parsing was completed there can be an error
if (!yajl_context.parser_ctxt.error == SEC_OK)
{
if (error_func)
error_func(yajl_get_bytes_consumed(yh), yajl_context.parser_ctxt.error,
SchemaGetErrorMessage(yajl_context.parser_ctxt.error), error_ctxt);
validator_unref(yajl_context.parser_ctxt.validator);
yajl_free(yh);
JsonSchemaParserFree(parser, free);
return NULL;
}
yajl_free(yh);
JsonSchemaParserFree(parser, free);
// Post-parse processing
Validator *v = yajl_context.parser_ctxt.validator;
// Move parsed features to the validators
validator_apply_features(v);
// Combine type validator and other validators contaiters (allOf, anyOf, etc.)
validator_combine(v);
if (uri_resolver)
validator_collect_uri(v, root_scope, uri_resolver);
// Substitute every SchemaParsing by its type validator for every node
// in the AST.
Validator *result = validator_finalize_parse(v);
// Forget about SchemaParsing then.
validator_unref(v);
return result;
}
int main()
{
int sfd,sfdcs,sfd1;
struct sockaddr_un serv_addr,client_addr;
struct sockaddr_un serv_addrcs,client_addres; //address of server1
struct sockaddr_un serv_addrs;
int lencs=sizeof(client_addres);
int len=sizeof(client_addr);
serv_addr.sun_family=AF_UNIX;
strcpy(serv_addr.sun_path,"echo_socket_s");
serv_addrs.sun_family=AF_UNIX;
strcpy(serv_addrs.sun_path,"echo_socket_se");
serv_addrcs.sun_family=AF_UNIX;
strcpy(serv_addrcs.sun_path,"echo_socket_cs");
sfdcs=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfdcs,"socket error");
sfd1=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd1,"socket error");
error_func(connect(sfd1,(struct sockaddr*)&serv_addrs,sizeof(serv_addrs)),"connect error");
send(sfd1,"From server s to server e",30,0);
sfd=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd,"socket error");
unlink(serv_addr.sun_path);
unlink(serv_addrcs.sun_path);
error_func(bind(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"bind error");
error_func(listen(sfd,5),"listen error");
error_func(bind(sfdcs,(struct sockaddr*)&serv_addrcs,sizeof(serv_addrcs)),"bind error");
error_func(listen(sfdcs,5),"listen error");
int nfdcs=accept(sfdcs,(struct sockaddr*)&client_addres,&lencs);
error_func(nfdcs,"accept error");
char buffer[30];
recv(nfdcs,buffer,sizeof(buffer),0);
printf("%s\n",buffer);
int nfd=accept(sfd,(struct sockaddr*)&client_addr,&len);
error_func(nfd,"accept error");
recv(nfd,buffer,sizeof(buffer),0);
printf("%s\n",buffer);
struct pollfd fdp[2];
fdp[0].fd=nfd;
fdp[0].events=POLLRDNORM;
fdp[1].fd=nfdcs;
fdp[1].events=POLLRDNORM;
int clients_no=0;
while(1)
{
error_func(poll(fdp,2,0),"poll error");
if(fdp[0].events & fdp[0].revents)
{
printf("%s\n","0 main selected");
int fd=recv_file_descriptor(nfd);
printf("File descriptor%d\n",fd);
if(clients_no >=max_clients)
{
//send clients to e server
printf("%s\n","max of s reached sending to e server");
send_file_descriptor(sfd1,fd);
perror("send:");
}
else
pthread_create(&threads[clients_no++],NULL,func,(void *)(&fd));
}
else if(fdp[1].events & fdp[1].revents)
{
printf("%s\n","1 s server selected");
int fd=recv_file_descriptor(nfdcs);
printf("File descriptor%d\n",fd);
if(clients_no>=max_clients)
{
//send clients to e server
printf("%s\n","max of s reached sending to e server");
send_file_descriptor(sfd1,fd);
perror("send:");
}
else
pthread_create(&threads[clients_no++],NULL,func,(void *)(&fd));
}
else
continue;
}
}
int main(int argc, char** argv)
{
cout << endl<< endl << "********************** program start************************ " << endl << endl;
int nx = 256, ny = 256, nz = 256, nn = nx*ny*nz;
FLOAT dx = Lx/(FLOAT)nx, dy = Ly/(FLOAT)ny, dz = Lz/(FLOAT)nz;
FLOAT dt = 0.1*dx*dx/KAPPA;
int step = 1000;
double elaps=0.0;
double getElapsedTime();
int thread_num=1;
#ifdef _OPENMP
#pragma omp parallel
{
thread_num = omp_get_num_threads();
if(omp_get_thread_num()==0)cout<<"\nUsed Number of Threads : "<< thread_num <<endl<<endl;
}
#endif
// To avoid chaching effects for small message sizes //
int fact = 1; for(;fact*nn*sizeof(FLOAT)<100e6;++fact);
cout << "fact = " << fact << endl;
// FLOAT* f = (FLOAT *)scalable_aligned_malloc(sizeof(FLOAT) * nn, SIMDALIGN);
//FLOAT* fn = (FLOAT *)scalable_aligned_malloc(sizeof(FLOAT) * nn, SIMDALIGN);
FLOAT* f = (FLOAT *)_mm_malloc(sizeof(FLOAT) * nn, SIMDALIGN);
FLOAT* fn = (FLOAT *)_mm_malloc(sizeof(FLOAT) * nn, SIMDALIGN);
initArray(f ,nx, ny, nz);
initArray(fn,nx, ny, nz);
long data = 0;
FLOAT flops=0.0;
startTiming();
for(int n = 0;n<step;++n){
// flops += diffusion_simd(nx, ny, nz, nn, dx, dy, dz, dt, f, fn);
// flops += diffusion_peel(nx, ny, nz, nn, dx, dy, dz, dt, f, fn);
flops += diffusion_tiled(nx, ny, nz, nn, dx, dy, dz, dt, f, fn);
data+=nn*2*sizeof(FLOAT);
swap(&f, &fn);
elaps += dt;
}
endTiming();
cout<<"Buffer Size: " <<sizeof(FLOAT)*nn/(1000.0*1000.0) <<" [MB] Total Data: "<<data/(1000.0*1000.0*1000.0)<<" [GB]"<<endl;
cout<<"Bandwidth: " <<data/(1000.0*1000.0*1000.0*getElapsedTime())<<"[GB/s]"<<endl;
cout<<"FLOPS : " <<flops/(1000.0*1000.0*1000.0*getElapsedTime())<<"[GFLOPS]"<<endl;
cout<<"Elapsed Time: " <<getElapsedTime()<<endl<<endl;
error_func(nx, ny, nz, dx, f, elaps);
// scalable_aligned_free(f );
// scalable_aligned_free(fn);
_mm_free(f );
_mm_free(fn);
return 0;
}
static
int run_sync(struct mad_decoder *decoder)
{
enum mad_flow (*error_func)(void *, struct mad_stream *, struct mad_frame *);
void *error_data;
int bad_last_frame = 0;
struct mad_stream *stream;
struct mad_frame *frame;
struct mad_synth *synth;
int result = 0;
if (decoder->input_func == 0)
return 0;
if (decoder->error_func) {
error_func = decoder->error_func;
error_data = decoder->cb_data;
}
else {
error_func = error_default;
error_data = &bad_last_frame;
}
stream = &decoder->sync->stream;
frame = &decoder->sync->frame;
synth = &decoder->sync->synth;
mad_stream_init(stream);
mad_frame_init(frame);
mad_synth_init(synth);
mad_stream_options(stream, decoder->options);
do {
switch (decoder->input_func(decoder->cb_data, stream)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
continue;
case MAD_FLOW_CONTINUE:
break;
}
while (1) {
if (decoder->header_func) {
if (mad_header_decode(&frame->header, stream) == -1) {
if (!MAD_RECOVERABLE(stream->error))
break;
switch (error_func(error_data, stream, frame)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
case MAD_FLOW_CONTINUE:
default:
continue;
}
}
switch (decoder->header_func(decoder->cb_data, &frame->header)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
continue;
case MAD_FLOW_CONTINUE:
break;
}
}
if (mad_frame_decode(frame, stream) == -1) {
if (!MAD_RECOVERABLE(stream->error))
break;
switch (error_func(error_data, stream, frame)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
break;
case MAD_FLOW_CONTINUE:
default:
continue;
}
}
else
bad_last_frame = 0;
if (decoder->filter_func) {
switch (decoder->filter_func(decoder->cb_data, stream, frame)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
continue;
case MAD_FLOW_CONTINUE:
break;
}
}
mad_synth_frame(synth, frame);
if (decoder->output_func) {
switch (decoder->output_func(decoder->cb_data,
&frame->header, &synth->pcm)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
case MAD_FLOW_CONTINUE:
break;
}
}
}
}
while (stream->error == MAD_ERROR_BUFLEN);
fail:
result = -1;
done:
mad_synth_finish(synth);
mad_frame_finish(frame);
mad_stream_finish(stream);
return result;
}
int main()
{
int pid=0;
pid=fork();
if(pid==0)
{
sleep(5);
printf("%s\n","child process");
int sfd;
struct sockaddr_un serv_addr;
serv_addr.sun_family=AF_UNIX;
strcpy(serv_addr.sun_path,"echo_socket");
sfd=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd,"socket error");
error_func(connect(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"connect error");
int fd=recv_file_descriptor(sfd);
printf("fd is child: %d\n",fd);
char buffer[30];
int nbytes;
while(1)
{
scanf("parent bytes?%d",&nbytes);
read(fd,buffer,nbytes);
printf("child :%s\n",buffer);
sleep(3);
}
send(sfd,"From client to server",30,0);
recv(sfd,buffer,sizeof(buffer),0);
printf("%s\n",buffer);
close(sfd);
}
else
{
printf("%s\n","parent process");
const char *filename = "sample.txt";
int fd = open(filename, O_RDWR);
printf("fd parent:%d\n",fd);
int sfd;
struct sockaddr_un serv_addr,client_addr;
int len=sizeof(client_addr);
serv_addr.sun_family=AF_UNIX;
strcpy(serv_addr.sun_path,"echo_socket");
sfd=socket(AF_UNIX,SOCK_STREAM,0);
error_func(sfd,"socket error");
unlink(serv_addr.sun_path);
error_func(bind(sfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr)),"bind error");
error_func(listen(sfd,5),"listen error");
int nfd=accept(sfd,(struct sockaddr*)&client_addr,&len);
error_func(nfd,"accept error");
send_file_descriptor(nfd,fd);
int nbytes;
char buffer1[30];
while(1)
{
scanf("parent bytes?%d",&nbytes);
read(fd,buffer1,nbytes);
printf("parent :%s\n",buffer1);
sleep(3);
}
char buffer[30];
recv(nfd,buffer,sizeof(buffer),0);
printf("%s\n",buffer);
send(nfd,"hello from server",30,0);
wait(NULL);
close(nfd);
close(sfd);
}
}
static
int run_sync(struct mad_decoder *decoder)
{
/*
if (decoder->input_func == 0)
return 0;
if (decoder->error_func) {
error_func = decoder->error_func;
//error_data = decoder->cb_data;
}
else {
error_func = error_default;
error_data = &bad_last_frame;
}
stream = &decoder->sync->stream;
frame = &decoder->sync->frame;
synth = &decoder->sync->synth;
mad_stream_init(stream);
mad_frame_init(frame);
mad_synth_init(synth);
mad_stream_options(stream, decoder->options);
*/
do {
switch (decoder->input_func(decoder->cb_data, stream)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
continue;
case MAD_FLOW_CONTINUE:
break;
}
while (1) {
# if defined(USE_ASYNC)
if (decoder->mode == MAD_DECODER_MODE_ASYNC) {
switch (check_message(decoder)) {
case MAD_FLOW_IGNORE:
case MAD_FLOW_CONTINUE:
break;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_STOP:
goto done;
}
}
# endif
if (decoder->header_func) {
if (mad_header_decode(&frame->header, stream) == -1) {
if (!MAD_RECOVERABLE(stream->error))
break;
switch (error_func(decoder->cb_data, stream, frame)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
case MAD_FLOW_CONTINUE:
default:
continue;
}
}
switch (decoder->header_func(decoder->cb_data, &frame->header)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
continue;
case MAD_FLOW_CONTINUE:
break;
}
}
if (mad_frame_decode(frame, stream) == -1) {
if (!MAD_RECOVERABLE(stream->error))
break;
switch (error_func(decoder->cb_data, stream, frame)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
break;
case MAD_FLOW_CONTINUE:
default:
continue;
}
}
else
bad_last_frame = 0;
if (decoder->filter_func) {
switch (decoder->filter_func(decoder->cb_data, stream, frame)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
continue;
case MAD_FLOW_CONTINUE:
break;
}
}
mad_synth_frame(synth, frame);
if (decoder->output_func) {
switch (decoder->output_func(decoder->cb_data,
&frame->header, &synth->pcm)) {
case MAD_FLOW_STOP:
goto done;
case MAD_FLOW_BREAK:
goto fail;
case MAD_FLOW_IGNORE:
case MAD_FLOW_CONTINUE:
break;
}
}
}
}
while (stream->error == MAD_ERROR_BUFLEN);
fail:
result = -1;
done:
/*
mad_synth_finish(synth);
mad_frame_finish(frame);
mad_stream_finish(stream);
*/
//return result;
return stream->this_frame - stream->buffer;
}
