void traitement(struct message* request) {
switch (request->type) {
case DIFFUSION:
broad_cast(request->content);
break;
case CONNEXION:
ajout_name(request->content);
break;
case DECONNEXION:
supp_name(request->content);
break;
default:
printf("error type de request\n");
}
}
void get_forces(struct chain_param *chain_pm, struct monomer *monomers, Float ***velcs_df, int n_step, VSLStreamStatePtr rngstream)
{
extern int n_proc, num_proc;
extern int num_x;
extern int max_x, max_y, max_z;
extern int wall_flag;
int mon_proc;
int num_beads, Nbead;
int i, j;
int n1, n2;
int s_type = 1; /* spring type : 0 = FENE, 1=WLC */
int ev_type = 1; /* ev type: 0=HS, 1=WCA, 2=Gaussian */
int maxsize[DIMS];
int max_N_flag=0;
double send_buffer[2*DIMS+1];
char filename[80];
FILE *stream;
maxsize[0]=max_x;
maxsize[1]=max_y;
maxsize[2]=max_z;
num_beads = chain_pm->num_beads;
Nbead = chain_pm->num_beads / chain_pm->Nchain;
for(j=0; j<DIMS; j++)
monomers[0].force[j] = monomers[0].f_ext[j];
for(n1=1; n1<num_beads; n1++)
for(j=0; j<DIMS; j++)
monomers[n1].force[j] = 0.0;
/* Calculate spring and exc. vol. forces if # of beads > 1 */
if(num_beads > 1) {
spring_force(chain_pm, monomers); /* 0 = FENE, 1=WLC */
/*excluded volume forces */
if(num_beads < 200)
ev_force(monomers[0].radius, chain_pm, monomers);
else {
for(n1=0; n1<num_beads; n1++)
if(monomers[n1].list[0] >= MAX_N-1) max_N_flag = 1;
if(max_N_flag == 1)
ev_force(monomers[0].radius, chain_pm, monomers);
else ev_force_nlist(monomers[0].radius, chain_pm, monomers);
}
}
for(n1=0; n1<num_beads; n1++)
for(j=0; j<DIMS; j++) {
monomers[n1].force[j] *= chain_pm->monmass;
monomers[n1].f_int[j] = monomers[n1].force[j];
}
/*hydrodynamic and fluctuation forces */
hi_force(monomers, velcs_df, chain_pm->fric, chain_pm->MD_steps, chain_pm->dt, num_beads, chain_pm->monmass, rngstream);
if(wall_flag > 0)
wall_force(chain_pm, monomers);
/* send forces and fluid_vel back to proc 0 then broadcast from 0 */
for(n1=0; n1< num_beads; n1++) {
mon_proc = (int)(monomers[n1].pos[0]/num_x);
send_buffer[0]=n1;
for(i=0; i<DIMS; i++) {
send_buffer[i+1]=monomers[n1].force[i];
send_buffer[i+DIMS+1]=monomers[n1].fluid_vel[i];
}
vector_copy(send_buffer, 2*DIMS+1, n_proc, mon_proc, 0);
for(i=0; i<DIMS; i++) {
monomers[(int)send_buffer[0]].force[i]=send_buffer[i+1];
monomers[(int)send_buffer[0]].fluid_vel[i]=send_buffer[i+1+DIMS];
}
}
sync_procs();
for(n1=0; n1< num_beads; n1++) {
broad_cast(monomers[n1].force, DIMS, 0);
broad_cast(monomers[n1].fluid_vel, DIMS, 0);
}
}
int serve(client_node_t* client) {
client->pid = getpid();
client_id = client->id;
signal(SIGUSR1, signal_handle);
int c;
// replace stdin, stdout, stderr to client fd
for(c=0; c<3; c++){
dup2(client->client_sc_fd, c);
}
for(c=0; c<client->num_env; c++) {
setenv(client->env[c], client->env_val[c], 1);
}
printf("%s\n", welcome_message);
fflush(stdout);
char broad_msg[1024];
bzero(broad_msg, 1024);
sprintf(broad_msg, "*** User '(no name)' entered from %s/%d. ***\n", client->ip, client->port);
broad_cast(client, broad_msg);
printf("%% ");
fflush(stdout);
while(1){
cmd_node_t* cmd_node_list = NULL;
parse_tokens(&cmd_node_list);
int state;
if(cmd_node_list != NULL) {
// handle_from_user_node(&cmd_node_list);
// process commands
// despatch node to right palce
while(cmd_node_list != NULL) {
cmd_node_t* node_to_exec = pull_cmd_node(&cmd_node_list);
if(node_to_exec->pipe_count == -1) {
break;
}
int errnum = exec_cmd_node(node_to_exec, client);
if(errnum == -1) {
// command not found
printf("Unknown command: [%s].\n", node_to_exec->cmd);
fflush(stdout);
free_cmd_list(&cmd_node_list);
} else if(errnum == -2) {
// pipe to me not exist
printf("*** Error: the pipe #%d->#%d does not exist yet. ***\n", node_to_exec->from_user_id, client->id);
fflush(stdout);
free_cmd_list(&cmd_node_list);
} else if(errnum == -3) {
// pipe to other exist
printf("*** Error: the pipe #%d->#%d already exists. ***\n", client->id, node_to_exec->to_user_id);
fflush(stdout);
} else if(errnum == -4) {
// logout
return -1;
}
}
}
printf("%% ");
fflush(stdout);
}
return 0;
}
int exec_cmd_node(cmd_node_t* cmd_node, client_node_t* client) {
int pipe_count = cmd_node->pipe_count;
int pid = -1;
int input_pipe_fd = -1;
int output_pipe_fd = -1;
if(strcmp(cmd_node->cmd, "printenv") == 0) {
char* env_name = cmd_node->args[1];
if(env_name != NULL) {
char* env_val = getenv(env_name);
printf("%s=%s\n", env_name, env_val);
fflush(stdout);
}
decrease_all_pipe_node(client->pipe_list);
return 0;
} else if(strcmp(cmd_node->cmd, "setenv") == 0) {
char* env_name = cmd_node->args[1];
char* env_val = cmd_node->args[2];
set_env_to_client_node(client, env_name, env_val);
setenv(env_name, env_val, 1);
decrease_all_pipe_node(client->pipe_list);
return 0;
} else if(strcmp(cmd_node->cmd, "exit") == 0) {
char exit_msg[64];
bzero(exit_msg, 64);
sprintf(exit_msg, "*** User '%s' left. ***\n", client->name);
broad_cast(client, exit_msg);
// clean message queues
mq_clean(client->id);
// remove global pipes
remove_global_pipe(client->id, client->id, 0);
// remove client from client list
remove_client_node(client);
// return logout status
return -4;
} else if(strcmp(cmd_node->cmd, "who") == 0) {
who(client);
decrease_all_pipe_node(client->pipe_list);
return 0;
} else if(strcmp(cmd_node->cmd, "tell") == 0) {
int r = tell(client, cmd_node->args[1], cmd_node->args[2]);
if(r == -1) {
printf("*** Error: user #%s does not exist yet. ***\n", cmd_node->args[1]);
fflush(stdout);
} else {
decrease_all_pipe_node(client->pipe_list);
}
return 0;
} else if(strcmp(cmd_node->cmd, "yell") == 0) {
char message[11000];
sprintf(message, "*** %s yelled ***: %s\n", client->name, cmd_node->args[1]);
bzero(message, 11000);
broad_cast(client, message);
decrease_all_pipe_node(client->pipe_list);
return 0;
} else if(strcmp(cmd_node->cmd, "name") == 0) {
char* name = cmd_node->args[1];
if(check_name_exist(name) == 1) {
printf("*** User '%s' already exists. ***\n", name);
fflush(stdout);
} else {
set_client_name(client->id, name);
strcpy(client->name, name);
char msg[40];
bzero(msg, 40);
sprintf(msg, "*** User from %s/%d is named '%s'. ***\n", client->ip, client->port, client->name);
broad_cast(client, msg);
fflush(stdout);
}
decrease_all_pipe_node(client->pipe_list);
return 0;
}
decrease_all_pipe_node(client->pipe_list);
// get this process input source
pipe_node_t* in_pipe_node = find_pipe_node_by_count(client->pipe_list, 0);
if(in_pipe_node != NULL) {
input_pipe_fd = in_pipe_node->in_fd;
if(fcntl(in_pipe_node->out_fd, F_GETFD) != -1) {
close(in_pipe_node->out_fd);
}
in_pipe_node->count--;
}
if(cmd_node->pipe_from_user == 1) {
char data[2048];
bzero(data, 2048);
int r = pull_global_pipe_data(cmd_node->from_user_id, client->id, data);
if(r == -1) {
inscrease_all_pipe_node(client->pipe_list);
return -2;
}
int g_pipe[2];
pipe(g_pipe);
write(g_pipe[1], r.msg, strlen(r.msg));
close(g_pipe[1]);
input_pipe_fd = g_pipe[0];
}
int tmp_global_pipe[2];
// get this process output source
pipe_node_t* out_pipe_node = find_pipe_node_by_count(client->pipe_list, pipe_count);
if(out_pipe_node != NULL) {
output_pipe_fd = out_pipe_node->out_fd;
} else if(cmd_node->pipe_to_file == 1){
output_pipe_fd = get_file_fd(cmd_node->filename);
} else if(cmd_node->pipe_to_user == 1) {
if(is_client_available(cmd_node->to_user_id) != 1) {
printf("*** Error: user #%d does not exist yet. ***\n", cmd_node->to_user_id);
fflush(stdout);
close_unused_fd(client);
return 0;
} else if(is_global_pipe_exist(client->id, cmd_node->to_user_id) == 1) {
close_unused_fd(client);
return -3;
}
// global pipe
// create global pipe node
pipe(tmp_global_pipe);
output_pipe_fd = tmp_global_pipe[1];
// broad cast message
// *** (name) (#<client id>) just piped '(command line)' to (receiver's name) (#<receiver's client_id>) ***
char* msg_temp = "*** %s (#%d) just piped '%s' to %s (#%d) ***\n";
char msg[128];
bzero(msg, 128);
char to_client_name[30];
get_client_name(cmd_node->to_user_id, to_client_name);
sprintf(msg, msg_temp, client->name, client->id, last_line, to_client_name, cmd_node->to_user_id);
broad_cast(client, msg);
fflush(stdout);
} else if(cmd_node->pipe_count != 0) {
int new_pipe_fd[2];
pipe(new_pipe_fd);
out_pipe_node = malloc(sizeof(pipe_node_t));
out_pipe_node->count = cmd_node->pipe_count;
out_pipe_node->in_fd = new_pipe_fd[0];
out_pipe_node->out_fd = new_pipe_fd[1];
out_pipe_node->next_node = NULL;
insert_pipe_node(&(client->pipe_list), out_pipe_node);
output_pipe_fd = new_pipe_fd[1];
}
pid = fork();
if(pid == 0) {
if(input_pipe_fd != -1) {
// not use stdin
close(0);
dup(input_pipe_fd);
close(input_pipe_fd);
}
// out
if(out_pipe_node != NULL) {
close(1);
dup(out_pipe_node->out_fd);
close(out_pipe_node->out_fd);
} else if(cmd_node->pipe_to_file == 1) {
close(1);
dup(output_pipe_fd);
close(output_pipe_fd);
} else if(cmd_node->pipe_to_user == 1) {
close(1);
close(2);
dup(output_pipe_fd);
dup(output_pipe_fd);
close(output_pipe_fd);
} else {
dup2(client->client_sc_fd, 1);
}
execvp(cmd_node->cmd, cmd_node->args);
exit(-1);
} else if(pipe_count != 0) {
int status;
wait(&status);
// waitpid(pid, &status, 0);
if(WEXITSTATUS(status) != 0){
inscrease_all_pipe_node(client->pipe_list);
return -1;
} else {
if(input_pipe_fd != -1) {
close(input_pipe_fd);
}
}
} else {
int status;
wait(&status);
// waitpid(pid, &status, 0);
if(WEXITSTATUS(status) != 0){
inscrease_all_pipe_node(client->pipe_list);
return -1;
} else {
if(in_pipe_node != NULL) {
close(in_pipe_node->out_fd);
in_pipe_node->count--;
}
if(cmd_node->pipe_to_user == 1) {
if(fcntl(output_pipe_fd, F_GETFD) != -1) {
close(output_pipe_fd);
}
char buffer[2048];
bzero(buffer, 2048);
read(tmp_global_pipe[0], buffer, 2048);
//printf("[DBG] Buffer:\n");
//printf("%s\n", buffer);
add_global_pipe(client->id, cmd_node->to_user_id, buffer);
close(tmp_global_pipe[0]);
}
close_unused_fd(client);
}
}
if(cmd_node->pipe_from_user == 1) {
char* msg_tmp = "*** %s (#%d) just received from %s (#%d) by '%s' ***\n";
char msg[100];
bzero(msg, 100);
char from_client_name[30];
get_client_name(cmd_node->from_user_id, from_client_name);
sprintf(msg, msg_tmp, client->name, client->id, from_client_name, cmd_node->from_user_id, last_line);
broad_cast(client, msg);
remove_global_pipe(cmd_node->from_user_id, client->id, 1);
}
return 0;
}
