/* open a connection to the given host and port or die.
* return socket fd.
*/
int
openINDIServer (char host[], int indi_port)
{
struct sockaddr_in serv_addr;
struct hostent *hp;
int sockfd;
/* lookup host address */
hp = gethostbyname (host);
if (!hp) {
fprintf (stderr, "gethostbyname(%s): %s\n", host, strerror(errno));
Bye();
}
/* create a socket to the INDI server */
(void) memset ((char *)&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr =
((struct in_addr *)(hp->h_addr_list[0]))->s_addr;
serv_addr.sin_port = htons(indi_port);
if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
fprintf (stderr, "socket(%s,%d): %s\n", host, indi_port,strerror(errno));
Bye();
}
/* connect */
if (connect (sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0){
fprintf (stderr, "connect(%s,%d): %s\n", host,indi_port,strerror(errno));
Bye();
}
/* ok */
return (sockfd);
}
DvrInfo * allocDvr ()
{
DvrInfo *dp = NULL;
int dvi;
/* try to reuse a drivber slot, else add one */
for (dvi = 0; dvi < ndvrinfo; dvi++)
if (!(dp = &dvrinfo[dvi])->active)
break;
if (dvi == ndvrinfo)
{
/* grow dvrinfo */
dvrinfo = (DvrInfo *) realloc (dvrinfo, (ndvrinfo+1)*sizeof(DvrInfo));
if (!dvrinfo) {
fprintf (stderr, "no memory for new drivers\n");
Bye();
}
dp = &dvrinfo[ndvrinfo++];
}
/* rig up new dvrinfo entry */
memset (dp, 0, sizeof(*dp));
dp->active = 1;
dp->ndev =0;
return dp;
}
void main()
{
int ret;
E_init();
system("clear");
sp_time test_timeout;
test_timeout.sec = 5;
test_timeout.usec = 0;
strncpy(Spread_name, "10080", 5);
ret = SP_connect_timeout( Spread_name, User, 0, 1, &Mbox, Private_group, test_timeout );
if( ret != ACCEPT_SESSION )
{
SP_error( ret );
Bye();
}
printf("Connected to %s with private group %s\n", Spread_name, Private_group );
E_attach_fd( 0, READ_FD, User_command, 0, NULL, LOW_PRIORITY );
E_attach_fd( Mbox, READ_FD, Read_message, 0, NULL, HIGH_PRIORITY );
show_menu();
for(;;)
{
E_handle_events();
User_command();
}
exit (0);
}
/* create the public INDI Driver endpoint lsocket on port.
* return server socket else exit.
*/
void
indiListen ()
{
struct sockaddr_in serv_socket;
int sfd;
int reuse = 1;
/* make socket endpoint */
if ((sfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
fprintf (stderr, "%s: socket: %s\n", indi_tstamp(NULL), strerror(errno));
Bye();
}
/* bind to given port for any IP address */
memset (&serv_socket, 0, sizeof(serv_socket));
serv_socket.sin_family = AF_INET;
#ifdef SSH_TUNNEL
serv_socket.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
#else
serv_socket.sin_addr.s_addr = htonl (INADDR_ANY);
#endif
serv_socket.sin_port = htons ((unsigned short)port);
if (setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0){
fprintf (stderr, "%s: setsockopt: %s\n", indi_tstamp(NULL),
strerror(errno));
Bye();
}
if (bind(sfd,(struct sockaddr*)&serv_socket,sizeof(serv_socket)) < 0){
fprintf (stderr, "%s: bind: %s\n", indi_tstamp(NULL), strerror(errno));
Bye();
}
/* willing to accept connections with a backlog of 5 pending */
if (listen (sfd, 5) < 0) {
fprintf (stderr, "%s: listen: %s\n", indi_tstamp(NULL), strerror(errno));
Bye();
}
/* ok */
lsocket = sfd;
if (verbose > 0)
fprintf (stderr, "%s: listening to port %d on fd %d\n",
indi_tstamp(NULL), port, sfd);
}
int main( int argc, char *argv[] )
{
int ret;
int mver, miver, pver;
sp_time test_timeout;
test_timeout.sec = 5;
test_timeout.usec = 0;
server_num = 0;
set_max_msgs(25);
if (!SP_version( &mver, &miver, &pver))
{
printf("main: Illegal variables passed to SP_version()\n");
Bye();
}
printf("Spread library version is %d.%d.%d\n", mver, miver, pver);
ret = SP_connect_timeout( SPREAD_NAME, NULL, 0, 1, &Mbox, Private_group, test_timeout );
if( ret != ACCEPT_SESSION )
{
SP_error( ret );
Bye();
}
printf("Client: connected to %s with private group %s\n", SPREAD_NAME, Private_group );
E_init();
E_attach_fd( 0, READ_FD, User_command, 0, NULL, LOW_PRIORITY );
E_attach_fd( Mbox, READ_FD, Read_message, 0, NULL, HIGH_PRIORITY );
Print_menu();
printf("\n > ");
fflush(stdout);
E_handle_events();
return( 0 );
}
/* start the given remote INDI driver connection.
* exit if trouble.
*/
void
startRemoteDvr (DvrInfo *dp)
{
Msg *mp;
char dev[1024];
char host[1024];
char buf[1024];
int indi_port, sockfd;
/* extract host and port */
indi_port = INDIPORT;
if (sscanf (dp->name, "%[^@]@%[^:]:%d", dev, host, &indi_port) < 2) {
fprintf (stderr, "Bad remote device syntax: %s\n", dp->name);
Bye();
}
/* connect */
sockfd = openINDIServer (host, indi_port);
/* record flag pid, io channels, init lp and snoop list */
dp->pid = REMOTEDVR;
dp->rfd = sockfd;
dp->wfd = sockfd;
dp->lp = newLilXML();
dp->msgq = newFQ(1);
dp->sprops = (Property*) malloc (1); /* seed for realloc */
dp->nsprops = 0;
dp->nsent = 0;
dp->active = 1;
dp->ndev = 1;
dp->dev = (char **) malloc(sizeof(char *));
/* N.B. storing name now is key to limiting outbound traffic to this
* dev.
*/
dp->dev[0] = (char *) malloc(MAXINDIDEVICE * sizeof(char));
strncpy (dp->dev[0], dev, MAXINDIDEVICE-1);
dp->dev[0][MAXINDIDEVICE-1] = '\0';
/* Sending getProperties with device lets remote server limit its
* outbound (and our inbound) traffic on this socket to this device.
*/
mp = newMsg();
pushFQ (dp->msgq, mp);
sprintf (buf, "<getProperties device='%s' version='%g'/>\n",
dp->dev[0], INDIV);
setMsgStr (mp, buf);
mp->count++;
if (verbose > 0)
fprintf (stderr, "%s: Driver %s: socket=%d\n", indi_tstamp(NULL),
dp->name, sockfd);
}
/*
* show characters that are already tty processed,
* and read characters before cononical processing
* we really use cbreak at PUCC because we need even parity...
*/
static void
C2Raw(int fd)
{
struct termios n_tios;
if (!isatty(fd) || 0 != screwy)
return;
if (0 != tcgetattr(fd, &o_tios)) {
Error("tcgetattr(%d): %s", fd, strerror(errno));
Bye(EX_UNAVAILABLE);
}
n_tios = o_tios;
n_tios.c_iflag &= ~(IUCLC | IXON);
n_tios.c_oflag &= ~OPOST;
n_tios.c_lflag &= ~(ISIG | ECHO | IEXTEN);
n_tios.c_cc[VMIN] = 1;
n_tios.c_cc[VTIME] = 0;
if (0 != tcsetattr(fd, TCSANOW, &n_tios)) {
Error("tcsetattr(%d, TCSANOW): %s", fd, strerror(errno));
Bye(EX_UNAVAILABLE);
}
screwy = 1;
}
virtual void bye(const Bye_t & arg)
{
// Header
wsa_.request(TO_TS_URL, SOAP_NAMESPACE_OF_wsd"/Bye");
wsa_.addAppSequence();
// Body
Wsa::Request<wsd__ByeType> req(RemoteDiscoveryBindingProxy::soap, arg);
req.Types = NULL;
req.Scopes = NULL;
req.XAddrs = NULL;
//req.MetadataVersion = &arg.version;
if (Bye(&req, NULL) != 0)
throw SoapException(RemoteDiscoveryBindingProxy::soap);
}
/* prepare for new client arriving on lsocket.
* exit if trouble.
*/
void
newClient()
{
ClInfo *cp = NULL;
int s, cli;
/* assign new socket */
s = newClSocket ();
/* try to reuse a clinfo slot, else add one */
for (cli = 0; cli < nclinfo; cli++)
if (!(cp = &clinfo[cli])->active)
break;
if (cli == nclinfo) {
/* grow clinfo */
clinfo = (ClInfo *) realloc (clinfo, (nclinfo+1)*sizeof(ClInfo));
if (!clinfo) {
fprintf (stderr, "no memory for new client\n");
Bye();
}
cp = &clinfo[nclinfo++];
}
/* rig up new clinfo entry */
memset (cp, 0, sizeof(*cp));
cp->active = 1;
cp->s = s;
cp->lp = newLilXML();
cp->msgq = newFQ(1);
cp->props = malloc (1);
cp->nsent = 0;
if (verbose > 0) {
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
getpeername(s, (struct sockaddr*)&addr, &len);
fprintf(stderr,"%s: Client %d: new arrival from %s:%d - welcome!\n",
indi_tstamp(NULL), cp->s, inet_ntoa(addr.sin_addr),
ntohs(addr.sin_port));
}
#ifdef OSX_EMBEDED_MODE
int active = 0;
for (int i = 0; i < nclinfo; i++)
if (clinfo[i].active)
active++;
fprintf(stderr, "CLIENTS %d\n", active); fflush(stderr);
#endif
}
/* Attempt to open up FIFO */
void indiFIFO(void)
{
close(fifo.fd);
fifo.fd=-1;
/* Open up FIFO, if available */
if (fifo.name)
{
fifo.fd = open(fifo.name, O_RDWR | O_NONBLOCK);
if (fifo.fd < 0)
{
fprintf(stderr, "%s: open(%s): %s.\n", indi_tstamp(NULL), fifo.name, strerror(errno));
Bye();
}
}
}
/* block to accept a new client arriving on lsocket.
* return private nonblocking socket or exit.
*/
int
newClSocket ()
{
struct sockaddr_in cli_socket;
socklen_t cli_len;
int cli_fd;
/* get a private connection to new client */
cli_len = sizeof(cli_socket);
cli_fd = accept (lsocket, (struct sockaddr *)&cli_socket, &cli_len);
if(cli_fd < 0) {
fprintf (stderr, "accept: %s\n", strerror(errno));
Bye();
}
/* ok */
return (cli_fd);
}
static void Handle_membership()
{
int i;
wack_alarm(LOGIC, "Handle_membership");
if( strcmp( Sender, Spread_group ) != 0 )
{
Bye();
Clean_up();
wack_alarm(EXIT, "Handle_membership: Bug! got a membership for group %s",
Sender );
}
memcpy( &Gid, Mess, sizeof( group_id ) );
Num_pending_states = Num_groups;
Num_members = Num_groups;
for( i = 0; i < Num_members; i++ )
{
memcpy( Members[i].private_group_name, Target_groups[i], MAX_GROUP_NAME );
My_index = Mess_type;
_rif_ip_s(Members[i]) = 0;
Members[i].num_allocated = 0;
Members[i].got_state_from = 0;
}
if(State != GATHER && State != BOOT)
memcpy( Old_table, Allocation_table, MAX_PSEUDO * sizeof( entry ) );
for ( i = 0; i < Num_pseudo; i++ )
{
_rif_ip_s(Allocation_table[i]) = 0;/* added 4/27/01 */
Allocation_table[i].claim_priority = UNCLAIMED;
}
Send_state_message(); /* ### */
wack_alarm(LOGIC, "Shifting to GATHER" );
State = GATHER;
wack_alarm(LOGIC, "Dequeuing Balance" ); /* Debug */
E_dequeue( Balance, 0, 0 );
}
static void User_command()
{
char command[130];
char mtext[80];
char mess[MAX_MESSLEN];
char group[80];
char groups[10][MAX_GROUP_NAME];
int num_groups;
unsigned int mess_len;
int ret;
int i;
int like;
sp_time test_timeout;
char server_id[1];
for( i=0; i < sizeof(command); i++ ) command[i] = 0;
if( fgets( command, 130, stdin ) == NULL )
Bye();
/* remove newline from string */
command[strlen(command) -1] = 0;
switch( command[0] )
{
case 'j':
ret = sscanf( &command[2], "%s", group );
if (connected > 0) {
if( ret < 1 )
{
printf(" invalid chatroom \n> ");
break;
}
join_room(group);
}
else {printf("You must connect to a server first\n>"); }
break;
case 'c':
ret = sscanf( &command[2], "%s", group );
if( ret < 1 )
{
printf(" invalid server id \n> ");
break;
}
join_server(group);
break;
case 'q':
Bye();
exit(0);
break;
case '?':
show_menu();
break;
case 'u':
if (connected > 0 ) {
ret = sscanf( &command[2], "%s", username);
if( ret < 1 )
{
printf(" Invalid Username\n> ");
break;
}
else
{
printf("Username set to %s\n> ", username);
/*If in chatroom, disconnect */
if (strlen(chatroom) > 0)
{
sprintf(chatroom, "%s%d",chatroom, connected);
printf("leaving chatroom, %s due to username change\n", chatroom);
SP_leave(Mbox, chatroom);
}
}
}
else {printf("You must connect to a server first\n>"); }
break;
case 'a':
if (connected > 0) {
strncpy(mtext, &command[2], 130);
if( strlen(mtext) < 1)
{
printf(" invalid message\n> ");
break;
}
send_msg(mtext);
}
else {printf("You must connect to a server first\n>"); }
break;
case 'l':
if (connected > 0) {
ret = sscanf( &command[2], "%d", &like );
if( ret < 1)
{
printf(" invalid line\n> ");
break;
}
like_msg(like, 1);
}
else {printf("You must connect to a server first\n>"); }
break;
case 'r':
if (connected > 0) {
ret = sscanf( &command[2], "%d", &like);
if (ret < 1)
{
printf(" invalid line\n> ");
break;
}
like_msg(like, 0);
}
else {printf("You must connect to a server first\n>"); }
break;
case 'h':
if (strlen(chatroom) != 0) {
print_history();
printf("> ");
}
else printf("You are not in a chatroom.\n>");
break;
case 'v':
if (connected > 0) {
show_servers();
}
else {printf("You must connect to a server first\n>"); }
break;
default:
printf("> ");
break;
}
fflush(stdout);
}
void setup(struct initializers *i) {
/* Sets up all ports */
/* and waits for the start_mcast message to start the actual process */
int mcast_addr;
int start = 0;
int bytes;
int num, c, num_groups, r, ret;
int service_type = 0;
int responded=0;
int16 mess_type;
int endian_mismatch=0;
int response[10];
struct timeval timeout;
unsigned char ttl_val;
char target_groups[MAX_MEMBERS][MAX_GROUP_NAME];
char logfilename[10];
char sender[MAX_GROUP_NAME];
char groups[10][MAX_GROUP_NAME];
char mess_buf[MAX_MESS_LEN];
sp_time test_timeout;
struct packet_structure *p=malloc(sizeof(struct packet_structure));
snprintf(logfilename, 10, "%d.out", machine_index);
logfile = fopen(logfilename, "w");
ret = SP_connect_timeout( Spread_name, User, 0, 1, &Mbox, Private_group, test_timeout );
if( ret != ACCEPT_SESSION )
{
SP_error( ret );
Bye();
}
printf("User: connected to %s with private group %s\n", Spread_name, Private_group );
E_init();
ret = SP_join(Mbox, group); printf("Join group %s:%d\n", group, ret);
if (machine_index == 1) {
for (c=1; c <= total_machines; c++) {
response[c] = 0;
completed[c] = 0;
}
/* Collect up the users, and send start message when everyone is in the group */
response[1]=1;
while (responded < 1) {
ret = SP_receive( Mbox, &service_type, sender, 100, &num_groups, target_groups,
&mess_type, &endian_mismatch, sizeof(mess_buf), mess_buf );
p = (struct packet_structure *)mess_buf;
if (p->type == 4) {
printf("ret = %d Got machine id %d\n", ret, p->machine_index);
/* Add this machine to the array and check to see if we are done */
response[p->machine_index] = 1;
printf("Got response from %d\n", p->machine_index);
r = 1;
for (c=1; c <= total_machines; c++) {
if (response[c] == 0) r =0;
}
if (r==1) responded = 1;
}
else if (p->type == 3 && machine_index == 1)
{
completed[p->machine_index] = 1;
}
}
/* Send start sending message to everyone */
if (r=1) /*All ready */ {
p->type= 2; printf("Ready to go..\n");
ret= SP_multicast( Mbox, AGREED_MESS, group, 1, sizeof(struct packet_structure), (char *)p );
}
}
else { /*We are not machine index 1*/
/*Send ready to begin message */
p->type = 4;
p->machine_index = machine_index;
ret= SP_multicast( Mbox, AGREED_MESS, group, 1, sizeof(struct packet_structure), (char *)p );
printf("Join=%d, group %s\n", ret, group);
if( ret < 0 )
{
SP_error( ret );
Bye();
}
else
{
printf("Sent: %d\n", ret);
}
}
};
void receive_packet() {
/* receiving data */
int c, ret, num_groups;
int r=1;
int16 mess_type;
int endian_mismatch=0;
char mess_buf[MAX_MESS_LEN];
char target_groups[MAX_MEMBERS][MAX_GROUP_NAME];
char sender[MAX_GROUP_NAME];
int service_type = 0;
struct timeval end_time;
struct packet_structure *packet;
SP_receive( Mbox, &service_type, sender, 100, &num_groups, target_groups,
&mess_type, &endian_mismatch, sizeof(mess_buf), mess_buf );
packet = (struct packet_structure *)mess_buf;
if (packet->type == 1) /*Data packet, write to log */
{
write_log(packet);
}
else if (packet->type == 3 && machine_index == 1)
{ printf("Checking for termination \n");
completed[packet->machine_index] = 1;
for (c=1; c <= total_machines; c++) {
if (completed[c] == 0) r =0;
printf("%d = %d\n", c, completed[c]);
}
if (r==1) {
/*All machines complete. Send termination */
packet->type = 5; printf("Complete sending termination\n");
ret= SP_multicast( Mbox, AGREED_MESS, group, 1, sizeof(struct packet_structure), (char *)packet );
}
}
else if (packet->type == 5) /*Terminate */
{
printf("Complete\n");
gettimeofday(&end_time, NULL);
starttime2=end_time.tv_sec+(end_time.tv_usec/1000000.0);
printf("%.6lf seconds elapsed\n", starttime2-starttime1);
fclose(logfile);
Bye();
exit (0);
}
else
{
printf("Got packet type %d, mid=%d\n", packet->type, packet->machine_index);
printf("received message of unknown message type 0x%x with ret %d\n", service_type, ret);
}
sendcount++; /* Only send when we've received at least what we've sent. */
if (packets_to_send > 0 && sendcount == FCC) {
sendcount = 0;
sp_time delta_time;
delta_time.sec = 0; delta_time.usec =1250; /*Setting this below 1000 causes problems */
E_queue( send_data, 0, NULL, delta_time ); /*Queue up the sender */
}
if (packets_to_send == 0 && completed[machine_index] == 0){ /*Send we are complete if we haven't already */
printf("Sending completed\n");
completed[machine_index] = 1;
packet->type = 3;
packet->machine_index = machine_index;
ret= SP_multicast( Mbox, AGREED_MESS, group, 1, sizeof(struct packet_structure), (char *)packet );
}
}
static void User_command()
{
char command[130];
char mess[MAX_MESSLEN];
char group[80];
char groups[10][MAX_GROUP_NAME];
int num_groups;
unsigned int mess_len;
int ret;
int i;
for( i=0; i < sizeof(command); i++ ) command[i] = 0;
if( fgets( command, 130, stdin ) == NULL )
Bye();
switch( command[0] )
{
case 'j':
ret = sscanf( &command[2], "%s", group );
if( ret < 1 )
{
printf(" invalid group \n");
break;
}
ret = SP_join( Mbox, group );
if( ret < 0 ) SP_error( ret );
break;
case 'l':
ret = sscanf( &command[2], "%s", group );
if( ret < 1 )
{
printf(" invalid group \n");
break;
}
ret = SP_leave( Mbox, group );
if( ret < 0 ) SP_error( ret );
break;
case 's':
num_groups = sscanf(&command[2], "%s%s%s%s%s%s%s%s%s%s",
groups[0], groups[1], groups[2], groups[3], groups[4],
groups[5], groups[6], groups[7], groups[8], groups[9] );
if( num_groups < 1 )
{
printf(" invalid group \n");
break;
}
printf("enter message: ");
if (fgets(mess, 200, stdin) == NULL)
Bye();
mess_len = strlen( mess );
#ifdef _REENTRANT
#ifdef __bsdi__ /* bsdi bug - doing a close when another thread blocks on the socket causes a seg fault */
ret = send( Mbox, mess, 0, 0 );
if( ret < 0 )
{
SP_error( CONNECTION_CLOSED );
Bye();
}
#endif /* __bsdi__ */
#endif /* _REENTRANT */
ret= SP_multigroup_multicast( Mbox, SAFE_MESS, num_groups, (const char (*)[MAX_GROUP_NAME]) groups, 1, mess_len, mess );
if( ret < 0 )
{
SP_error( ret );
Bye();
}
Num_sent++;
break;
case 'b':
ret=sscanf( &command[2], "%s", group );
if( ret != 1 ) strcpy( group, "dummy_group_name" );
printf("enter size of each message: ");
if (fgets(mess, 200, stdin) == NULL)
Bye();
ret=sscanf(mess, "%u", &mess_len );
if( ret !=1 ) mess_len = Previous_len;
if( mess_len > MAX_MESSLEN ) mess_len = MAX_MESSLEN;
Previous_len = mess_len;
printf("sending 10 messages of %u bytes\n", mess_len );
for( i=0; i<10; i++ )
{
Num_sent++;
sprintf( mess, "mess num %d ", Num_sent );
#ifdef _REENTRANT
#ifdef __bsdi__ /* bsdi bug - doing a close when another thread blocks on the socket causes a seg fault */
ret = send( Mbox, mess, 0,0 );
if( ret < 0 )
{
SP_error( CONNECTION_CLOSED );
Bye();
}
#endif /* __bsdi__ */
#endif /* _REENTRANT */
ret= SP_multicast( Mbox, FIFO_MESS, group, 2, mess_len, mess );
if( ret < 0 )
{
SP_error( ret );
Bye();
}
printf("sent message %d (total %d)\n", i+1, Num_sent );
}
break;
#ifndef _REENTRANT
case 'r':
Read_message();
break;
case 'p':
ret = SP_poll( Mbox );
printf("Polling sais: %d\n", ret );
break;
case 'e':
E_attach_fd( Mbox, READ_FD, Read_message, 0, NULL, HIGH_PRIORITY );
break;
case 'd':
E_detach_fd( Mbox, READ_FD );
break;
#endif /* _REENTRANT */
case 'q':
Bye();
break;
default:
printf("\nUnknown commnad\n");
Print_menu();
break;
}
printf("\nUser> ");
fflush(stdout);
}
int main( int argc, char *argv[] )
{
int ret;
#ifdef SPREAD_VERSION
int mver, miver, pver;
#endif
sp_time test_timeout;
test_timeout.sec = 5;
test_timeout.usec = 0;
Usage( argc, argv );
#ifdef SPREAD_VERSION
if (!SP_version( &mver, &miver, &pver))
{
printf("main: Illegal variables passed to SP_version()\n");
Bye();
}
printf("Spread library version is %d.%d.%d\n", mver, miver, pver);
#else
printf("Spread library version is %1.2f\n", SP_version() );
#endif
#ifdef ENABLE_PASSWORD
if (Use_Pword)
{
strncpy(Pword_user.username, Pword_username, 32);
Pword_user.username[32] = '\0';
strncpy(Pword_user.password, Pword_password, 8);
Pword_user.password[8] = '\0';
SP_set_auth_method("PWORD", pword_authenticate, &Pword_user);
}
#endif
ret = SP_connect_timeout( Spread_name, User, 0, 1, &Mbox, Private_group, test_timeout );
if( ret != ACCEPT_SESSION )
{
SP_error( ret );
Bye();
}
printf("User: connected to %s with private group %s\n", Spread_name, Private_group );
#ifndef _REENTRANT
E_init();
E_attach_fd( 0, READ_FD, User_command, 0, NULL, LOW_PRIORITY );
E_attach_fd( Mbox, READ_FD, Read_message, 0, NULL, HIGH_PRIORITY );
#endif /* _REENTRANT */
Print_menu();
printf("\nUser> ");
fflush(stdout);
Num_sent = 0;
#ifdef _REENTRANT
#ifndef ARCH_PC_WIN95
ret = pthread_create( &Read_pthread, NULL, Read_thread_routine, 0 );
#else /* ARCH_PC_WIN95 */
Read_pthread = CreateThread( NULL, 0, Read_thread_routine, NULL, 0, &ret );
#endif /* ARCH_PC_WIN95 */
for(;;)
{
User_command();
#ifdef __bsdi__
/* bug in BSDI */
sched_yield();
#endif
}
#else /* _REENTRANT */
#ifndef ARCH_PC_WIN95
E_handle_events();
#else /* ARCH_PC_WIN95 */
for(;;)
User_command();
#endif /* ARCH_PC_WIN95 */
#endif /* _REENTRANT */
return( 0 );
}
/* service traffic from clients and drivers */
void
indiRun(void)
{
fd_set rs, ws;
int maxfd=0;
int i, s;
/* init with no writers or readers */
FD_ZERO(&ws);
FD_ZERO(&rs);
if (fifo.name && fifo.fd >=0)
{
FD_SET(fifo.fd, &rs);
maxfd = fifo.fd;
}
/* always listen for new clients */
FD_SET(lsocket, &rs);
if (lsocket > maxfd)
maxfd = lsocket;
/* add all client readers and client writers with work to send */
for (i = 0; i < nclinfo; i++) {
ClInfo *cp = &clinfo[i];
if (cp->active) {
FD_SET(cp->s, &rs);
if (nFQ(cp->msgq) > 0)
FD_SET(cp->s, &ws);
if (cp->s > maxfd)
maxfd = cp->s;
}
}
/* add all driver readers and driver writers with work to send */
for (i = 0; i < ndvrinfo; i++)
{
DvrInfo *dp = &dvrinfo[i];
if (dp->active)
{
FD_SET(dp->rfd, &rs);
if (dp->rfd > maxfd)
maxfd = dp->rfd;
if (dp->pid != REMOTEDVR)
{
FD_SET(dp->efd, &rs);
if (dp->efd > maxfd)
maxfd = dp->efd;
}
if (nFQ(dp->msgq) > 0)
{
FD_SET(dp->wfd, &ws);
if (dp->wfd > maxfd)
maxfd = dp->wfd;
}
}
}
/* wait for action */
s = select (maxfd+1, &rs, &ws, NULL, NULL);
if (s < 0) {
fprintf (stderr, "%s: select(%d): %s\n", indi_tstamp(NULL), maxfd+1,
strerror(errno));
Bye();
}
/* new command from FIFO? */
if (s > 0 && fifo.fd >= 0 && FD_ISSET(fifo.fd, &rs))
{
newFIFO();
s--;
}
/* new client? */
if (s > 0 && FD_ISSET(lsocket, &rs)) {
newClient();
s--;
}
/* message to/from client? */
for (i = 0; s > 0 && i < nclinfo; i++) {
ClInfo *cp = &clinfo[i];
if (cp->active) {
if (FD_ISSET(cp->s, &rs)) {
if (readFromClient(cp) < 0)
return; /* fds effected */
s--;
}
if (s > 0 && FD_ISSET(cp->s, &ws)) {
if (sendClientMsg(cp) < 0)
return; /* fds effected */
s--;
}
}
}
/* message to/from driver? */
for (i = 0; s > 0 && i < ndvrinfo; i++) {
DvrInfo *dp = &dvrinfo[i];
if (dp->pid != REMOTEDVR && FD_ISSET(dp->efd, &rs)) {
if (stderrFromDriver(dp) < 0)
return; /* fds effected */
s--;
}
if (s > 0 && FD_ISSET(dp->rfd, &rs)) {
if (readFromDriver(dp) < 0)
return; /* fds effected */
s--;
}
if (s > 0 && FD_ISSET(dp->wfd, &ws) && nFQ(dp->msgq) > 0) {
if (sendDriverMsg(dp) < 0)
return; /* fds effected */
s--;
}
}
}
static void User_command()
{
char command[130];
char client_group[13];
char mess[SPREAD_MESS_LEN];
char group[MAX_ROOM_LEN - strlen("CR#_")];
char groups[10][MAX_GROUP_NAME];
int num_groups;
unsigned int mess_len;
int ret;
int srv;
int i;
for( i=0; i < sizeof(command); i++ ) command[i] = 0;
if( fgets( command, 130, stdin ) == NULL )
Bye();
switch( command[0] )
{
case 'u':
ret = sscanf( &command[2], "%s", u_id);
if (ret < 1 )
printf("invalid username\n");
break;
case 'c':
ret = sscanf( &command[2], "%d", &srv);
if ( ret < 1 || isValidServer(srv) != 1) { //isValid sets server_num
printf("invalid server index\n");
break;
}
ret = sprintf( client_group, "client_group%d",server_num);
if (ret < 1) {
printf("Error connecting to server-client group\n");
break;
}
ret = SP_join(Mbox, client_group);
if (ret < 0) SP_error( ret );
sprintf( server_priv_group, "server%d", server_num);
break;
case 'j':
//check if already in room
if (strlen(chatroom) > 0) {
clear_room(chatroom);
}
else {
ret = sscanf( &command[2], "%s", chatroom );
if( ret < 1 ) {
printf(" invalid chatroom name \n");
break;}
add_room(chatroom);
}
if (strlen(u_id) > 0 && isValidServer(server_num)) { //need valid username + server for chatroom
ret = sprintf ( group, "%s%d_%s","CR",server_num,chatroom);
if (ret < 1) {
printf("Error creating chatroom name <%s> from group <%s>\n",chatroom,group);
break;
}
ret = SP_join( Mbox, group ); //join CR#_<group> spread group
if( ret < 0 ) SP_error( ret );
}
else {
printf("Invalid username or server number, cannot join chatroom\n"); break;}
join_chatroom* send = (join_chatroom*)mess;
send->type = TYPE_JOIN_CHATROOM;
send->source = SOURCE_CLIENT;
strncpy(send->u_id,u_id,MAX_NAME_LEN);
strncpy(send->chatroom,chatroom,MAX_ROOM_LEN); //send <group> as chatroom spread name
ret = SP_multicast( Mbox, AGREED_MESS, server_priv_group, 1, sizeof(join_chatroom), mess );
if( ret < 0 )
{
SP_error( ret );
Bye();
}
break;
/*
case 'x':{
char ms[6];
add_room(chatroom);
set_max_msgs(25);
int maxi = 40;
for (int i = 1; i <= maxi;i++) {
struct lamport* ts = malloc(sizeof(lamport));
ts->server_id = 1;
ts->index = i;
sprintf(ms,"%s%d","asdfd",i);
add_message(ts,u_id,chatroom,ms);
if (i % 3 == 0 || i % 4 == 1 || i % 6 == 2) {
i++; maxi++;
struct lamport* ls = malloc(sizeof(lamport));
ls->server_id = 1;
ls->index = i;
add_like(LIKE,ls,u_id,chatroom,ts);
if (i % 6 == 2){
i++;maxi++;
char newu[MAX_NAME_LEN];
sprintf(newu,"%sx",u_id);
struct lamport* qs = malloc(sizeof(lamport));
qs->server_id = 1;
qs->index = i;
add_like(LIKE,qs,newu,chatroom,ts);
}
}
if (i % 4 == 1) {
i++; maxi++;
struct lamport* ls = malloc(sizeof(lamport));
ls->server_id = 1;
ls->index = i;
add_like(UNLIKE,ls,u_id,chatroom,ts);
}
}
printf("== %s ==\n",chatroom);
print_room(chatroom);
break;}
*/
case 'a': {
char text[MAX_MESS_LEN];
printf("enter message: ");
if (fgets(text, MAX_MESS_LEN, stdin) == NULL)
Bye();
if (strlen(chatroom) < 1){
printf("Please join a chatroom\n");
break;
}
message* dat = (message*)mess;
dat->type = TYPE_SEND_MSG;
dat->source = SOURCE_CLIENT;
strncpy(dat->u_id,u_id,MAX_NAME_LEN);
strncpy(dat->chatroom,chatroom,MAX_ROOM_LEN);
strncpy(dat->mess,text,MAX_MESS_LEN);
ret= SP_multicast( Mbox, AGREED_MESS, server_priv_group, 1, sizeof(message), mess );
if( ret < 0 )
{
SP_error( ret );
Bye();
}
break;
}
case 'l':
{
if (strlen(chatroom) < 1){
printf("Please join a chatroom\n");
break;}
int linenum;
ret = sscanf( &command[2], "%d", &linenum );
printf("Liking line %d.....\n",linenum);
if( ret < 1 ) {
printf(" invalid linenum \n");
break;}
lamport* stamp = get_msg_stamp(linenum);
printf("%d. index %d?\n",linenum,stamp->index);
like* dat = (like*)mess;
dat->type = TYPE_LIKE_MSG;
dat->source = SOURCE_CLIENT;
dat->msg_timestamp.server_id = stamp->server_id;
dat->msg_timestamp.index = stamp->index;
strncpy(dat->u_id,u_id,MAX_NAME_LEN);
strncpy(dat->chatroom,chatroom,MAX_ROOM_LEN);
dat->like_state = LIKE;
ret = SP_multicast( Mbox, AGREED_MESS, server_priv_group, 1, sizeof(like), mess);
if (ret < 0) {
SP_error(ret); Bye; }
break;
}
case 'r':
{
if (strlen(chatroom) < 1){
printf("Please join a chatroom\n");
break;}
int linenum;
ret = sscanf( &command[2], "%d", linenum );
if( ret < 1 ) {
printf(" invalid linenum \n");
break;}
lamport* stamp = get_msg_stamp(linenum);
printf("%d. index %d?\n",linenum,stamp->index);
like* dat = (like*)mess;
dat->type = TYPE_LIKE_MSG;
dat->source = SOURCE_CLIENT;
dat->msg_timestamp.server_id = stamp->server_id;
dat->msg_timestamp.index = stamp->index;
strncpy(dat->u_id,u_id,MAX_NAME_LEN);
strncpy(dat->chatroom,chatroom,MAX_ROOM_LEN);
dat->like_state = UNLIKE;
ret = SP_multicast( Mbox, AGREED_MESS, server_priv_group, 1, sizeof(like), mess);
if (ret < 0) {
SP_error(ret); Bye; }
break;
}
case 'h':
printf("history not implemented\n");
break;
case 'v':
printf("network view not implemented\n");
break;
case 'q':
Bye();
break;
default:
printf("\nUnknown commnad\n");
Print_menu();
break;
}
printf(" \n > ");
fflush(stdout);
}
/* start the given local INDI driver process.
* exit if trouble.
*/
void
startLocalDvr (DvrInfo *dp)
{
Msg *mp;
char buf[32];
int rp[2], wp[2], ep[2];
int pid;
#ifdef OSX_EMBEDED_MODE
fprintf(stderr, "STARTING \"%s\"\n", dp->name); fflush(stderr);
#endif
/* build three pipes: r, w and error*/
if (pipe (rp) < 0) {
fprintf (stderr, "%s: read pipe: %s\n", indi_tstamp(NULL),
strerror(errno));
Bye();
}
if (pipe (wp) < 0) {
fprintf (stderr, "%s: write pipe: %s\n", indi_tstamp(NULL),
strerror(errno));
Bye();
}
if (pipe (ep) < 0) {
fprintf (stderr, "%s: stderr pipe: %s\n", indi_tstamp(NULL),
strerror(errno));
Bye();
}
/* fork&exec new process */
pid = fork();
if (pid < 0) {
fprintf (stderr, "%s: fork: %s\n", indi_tstamp(NULL), strerror(errno));
Bye();
}
if (pid == 0) {
/* child: exec name */
int fd;
/* rig up pipes */
dup2 (wp[0], 0); /* driver stdin reads from wp[0] */
dup2 (rp[1], 1); /* driver stdout writes to rp[1] */
dup2 (ep[1], 2); /* driver stderr writes to e[]1] */
for (fd = 3; fd < 100; fd++)
(void) close (fd);
if (*dp->envDev)
setenv("INDIDEV", dp->envDev, 1);
/* Only reset environment variable in case of FIFO */
else if (fifo.fd > 0)
unsetenv("INDIDEV");
if (*dp->envConfig)
setenv("INDICONFIG", dp->envConfig, 1);
else if (fifo.fd > 0)
unsetenv("INDICONFIG");
if (*dp->envSkel)
setenv("INDISKEL", dp->envSkel, 1);
else if (fifo.fd > 0)
unsetenv("INDISKEL");
char executable[MAXSBUF];
if (*dp->envPrefix)
{
setenv("INDIPREFIX", dp->envPrefix, 1);
#ifdef OSX_EMBEDED_MODE
snprintf(executable, MAXSBUF, "%s/Contents/MacOS/%s", dp->envPrefix, dp->name);
#else
snprintf(executable, MAXSBUF, "%s/bin/%s", dp->envPrefix, dp->name);
#endif
fprintf(stderr, "%s\n", executable);
execlp (executable, dp->name, NULL);
}
else
{
if (fifo.fd > 0)
unsetenv("INDIPREFIX");
execlp (dp->name, dp->name, NULL);
}
#ifdef OSX_EMBEDED_MODE
fprintf(stderr, "FAILED \"%s\"\n", dp->name); fflush(stderr);
#endif
fprintf (stderr, "%s: Driver %s: execlp: %s\n", indi_tstamp(NULL),
dp->name, strerror(errno));
_exit (1); /* parent will notice EOF shortly */
}
/* don't need child's side of pipes */
close (wp[0]);
close (rp[1]);
close (ep[1]);
/* record pid, io channels, init lp and snoop list */
dp->pid = pid;
dp->rfd = rp[0];
dp->wfd = wp[1];
dp->efd = ep[0];
dp->lp = newLilXML();
dp->msgq = newFQ(1);
dp->sprops = (Property*) malloc (1); /* seed for realloc */
dp->nsprops = 0;
dp->nsent = 0;
dp->active = 1;
dp->ndev = 0;
dp->dev = (char **) malloc(sizeof(char *));
/* first message primes driver to report its properties -- dev known
* if restarting
*/
mp = newMsg();
pushFQ (dp->msgq, mp);
sprintf (buf, "<getProperties version='%g'/>\n", INDIV);
setMsgStr (mp, buf);
mp->count++;
if (verbose > 0)
fprintf (stderr, "%s: Driver %s: pid=%d rfd=%d wfd=%d efd=%d\n",
indi_tstamp(NULL), dp->name, dp->pid, dp->rfd, dp->wfd, dp->efd);
}
