/*
* SOCKDGRAM is unreliable, so we must repeat messages if we have
* not received an acknowledgement within a reasonable amount
* of time
*/
void
ctl_transact(struct in_addr target, CTL_MSG lmsg, int type, CTL_RESPONSE *rp)
{
fd_set read_mask, ctl_mask;
int nready = 0, cc;
struct timeval wait;
lmsg.type = type;
daemon_addr.sin_addr = target;
daemon_addr.sin_port = daemon_port;
FD_ZERO(&ctl_mask);
FD_SET(ctl_sockt, &ctl_mask);
/*
* Keep sending the message until a response of
* the proper type is obtained.
*/
do {
wait.tv_sec = CTL_WAIT;
wait.tv_usec = 0;
/* resend message until a response is obtained */
do {
cc = sendto(ctl_sockt, (char *)&lmsg, sizeof (lmsg), 0,
(struct sockaddr *)&daemon_addr,
sizeof (daemon_addr));
if (cc != sizeof (lmsg)) {
if (errno == EINTR)
continue;
p_error("Error on write to talk daemon");
}
read_mask = ctl_mask;
nready = select(32, &read_mask, 0, 0, &wait);
if (nready < 0) {
if (errno == EINTR)
continue;
p_error("Error waiting for daemon response");
}
} while (nready == 0);
/*
* Keep reading while there are queued messages
* (this is not necessary, it just saves extra
* request/acknowledgements being sent)
*/
do {
cc = recv(ctl_sockt, (char *)rp, sizeof (*rp), 0);
if (cc < 0) {
if (errno == EINTR)
continue;
p_error("Error on read from talk daemon");
}
read_mask = ctl_mask;
/* an immediate poll */
timerclear(&wait);
nready = select(32, &read_mask, 0, 0, &wait);
} while (nready > 0 && (rp->vers != TALK_VERSION ||
rp->type != type));
} while (rp->vers != TALK_VERSION || rp->type != type);
rp->id_num = ntohl(rp->id_num);
rp->addr.sa_family = ntohs(rp->addr.sa_family);
}
/*
* Trade edit characters with the other talk. By agreement
* the first three characters each talk transmits after
* connection are the three edit characters.
*/
void
set_edit_chars(void)
{
char buf[3];
int cc;
struct termios tio;
tcgetattr(0, &tio);
my_win.cerase = tio.c_cc[VERASE];
my_win.kill = tio.c_cc[VKILL];
my_win.werase = tio.c_cc[VWERASE];
if (my_win.cerase == (char)_POSIX_VDISABLE)
my_win.kill = CERASE;
if (my_win.kill == (char)_POSIX_VDISABLE)
my_win.kill = CKILL;
if (my_win.werase == (char)_POSIX_VDISABLE)
my_win.werase = CWERASE;
buf[0] = my_win.cerase;
buf[1] = my_win.kill;
buf[2] = my_win.werase;
cc = write(sockt, buf, sizeof(buf));
if (cc != sizeof(buf) )
p_error("Lost the connection");
cc = read(sockt, buf, sizeof(buf));
if (cc != sizeof(buf) )
p_error("Lost the connection");
his_win.cerase = buf[0];
his_win.kill = buf[1];
his_win.werase = buf[2];
}
/*
* Trade edit characters with the other talk. By agreement
* the first three characters each talk transmits after
* connection are the three edit characters.
*/
void
set_edit_chars(void)
{
char buf[3];
int cc;
struct termios tty;
tcgetattr(0, &tty);
my_win.cerase = tty.c_cc[VERASE];
my_win.kill = tty.c_cc[VKILL];
if (tty.c_cc[VWERASE] == (unsigned char) -1)
my_win.werase = '\027'; /* control W */
else
my_win.werase = tty.c_cc[VWERASE];
buf[0] = my_win.cerase;
buf[1] = my_win.kill;
buf[2] = my_win.werase;
cc = write(sockt, buf, sizeof(buf));
if (cc != sizeof(buf) )
p_error("Lost the connection");
cc = read(sockt, buf, sizeof(buf));
if (cc != sizeof(buf) )
p_error("Lost the connection");
his_win.cerase = buf[0];
his_win.kill = buf[1];
his_win.werase = buf[2];
}
/* Sinusoidal inverse equations--mapping x,y to lat,long
-----------------------------------------------------*/
int sininv(
double x, /* (I) X projection coordinate */
double y, /* (I) Y projection coordinate */
double *lon, /* (O) Longitude */
double *lat) /* (O) Latitude */
{
double temp; /* Re-used temporary variable */
double mu, ml;
double sin_phi, cos_phi;
/* Inverse equations
-----------------*/
x -= false_easting;
y -= false_northing;
if (ind != 0) /* Spherical */
{
*lat = y / R;
if (fabs(*lat) > HALF_PI)
{
p_error("Input data error","sinusoidal-inverse");
return(164);
}
temp = fabs(*lat) - HALF_PI;
if (fabs(temp) > EPSLN)
{
temp = lon_center + x / (R * cos(*lat));
*lon = adjust_lon(temp);
}
else *lon = lon_center;
return(OK);
}
else /* Ellipsoidal */
{
ml = y;
mu = ml / (r_major * imu);
*lat = mu +
(e2 * sin(2.0 * mu)) +
(e3 * sin(4.0 * mu)) +
(e4 * sin(6.0 * mu)) +
(e5 * sin(8.0 * mu));
if (fabs(*lat) > HALF_PI)
{
p_error("Input data error","sinusoidal-inverse");
return(164);
}
temp = fabs(*lat) - HALF_PI;
if (fabs(temp) > EPSLN)
{
sin_phi = sin(*lat);
cos_phi = cos(*lat);
temp = lon_center +
x * sqrt(1.0 - es * SQUARE(sin_phi)) / (r_major * cos_phi);
*lon = adjust_lon(temp);
}
else *lon = lon_center;
return(OK);
}
}
int
invite_remote (void)
{
int new_sockt;
struct itimerval itimer;
CTL_RESPONSE response;
itimer.it_value.tv_sec = RING_WAIT;
itimer.it_value.tv_usec = 0;
itimer.it_interval = itimer.it_value;
if (listen (sockt, 5) != 0)
p_error ("Error on attempt to listen for caller");
msg.addr.sa_family = htons (my_addr.sin_family);
memcpy (msg.addr.sa_data,
((struct sockaddr *) &my_addr)->sa_data,
sizeof ((struct sockaddr *) & my_addr)->sa_data);
msg.id_num = htonl (-1); /* an impossible id_num */
invitation_waiting = 1;
announce_invite ();
/*
* Shut off the automatic messages for a while,
* so we can use the interupt timer to resend the invitation
*/
end_msgs ();
setitimer (ITIMER_REAL, &itimer, (struct itimerval *) 0);
message ("Waiting for your party to respond");
signal (SIGALRM, re_invite);
setjmp (invitebuf);
while ((new_sockt = accept (sockt, 0, 0)) < 0)
{
if (errno == EINTR)
continue;
p_error ("Unable to connect with your party");
}
close (sockt);
sockt = new_sockt;
/*
* Have the daemons delete the invitations now that we
* have connected.
*/
current_state = "Waiting for your party to respond";
start_msgs ();
msg.id_num = htonl (local_id);
ctl_transact (my_machine_addr, msg, DELETE, &response);
msg.id_num = htonl (remote_id);
ctl_transact (his_machine_addr, msg, DELETE, &response);
invitation_waiting = 0;
return 0;
}
int p_close(p_team_t team)
{
struct team *pteam = p_to_team(team);
if (p_error(pteam))
p_error(pteam);
if (pteam->dev->dev_ops->close)
return pteam->dev->dev_ops->close(pteam->dev, pteam);
return 0;
}
/*
* Get simple payload from file
*/
int getpayload(char *path) {
FILE *file;
// open file
if((file=fopen(path, "r"))==NULL)
p_error("\nError opening payload file.\n");
if(!fread(progopt.payload, 1, MAX_ARG*4-1, file))
p_error("\nError reading payload from file.\n");
fclose(file);
return 1;
}
/*
* See if the local daemon has an invitation for us.
*/
int
check_local(void)
{
CTL_RESPONSE response;
CTL_RESPONSE *rp = &response;
struct sockaddr addr;
/* the rest of msg was set up in get_names */
#ifdef MSG_EOR
/* copy new style sockaddr to old, swap family (short in old) */
msg.ctl_addr = *(struct osockaddr *)&ctl_addr;
msg.ctl_addr.sa_family = htons(ctl_addr.sin_family);
#else
msg.ctl_addr = *(struct sockaddr *)&ctl_addr;
#endif
/* must be initiating a talk */
if (!look_for_invite(rp))
return (0);
/*
* There was an invitation waiting for us,
* so connect with the other (hopefully waiting) party
*/
current_state = "Waiting to connect with caller";
do {
if (rp->addr.sa_family != AF_INET)
p_error("Response uses invalid network address");
(void)memcpy(&addr, &rp->addr.sa_family, sizeof(addr));
addr.sa_family = rp->addr.sa_family;
addr.sa_len = sizeof(addr);
errno = 0;
if (connect(sockt, &addr, sizeof(addr)) != -1)
return (1);
} while (errno == EINTR);
if (errno == ECONNREFUSED) {
/*
* The caller gave up, but his invitation somehow
* was not cleared. Clear it and initiate an
* invitation. (We know there are no newer invitations,
* the talkd works LIFO.)
*/
ctl_transact(his_machine_addr, msg, DELETE, rp);
close(sockt);
open_sockt();
return (0);
}
p_error("Unable to connect with initiator");
/*NOTREACHED*/
return (0);
}
/* open the ctl socket */
open_ctl()
{
int length;
ctl_addr.sin_port = 0;
ctl_addr.sin_addr = my_machine_addr;
ctl_sockt = socket(AF_INET, SOCK_DGRAM, 0);
if (ctl_sockt <= 0)
p_error("Bad socket");
if (bind(ctl_sockt, (struct sockaddr *)&ctl_addr, sizeof(ctl_addr)) != 0)
p_error("Couldn't bind to control socket");
length = sizeof(ctl_addr);
if (getsockname(ctl_sockt, (struct sockaddr *)&ctl_addr, &length) == -1)
p_error("Bad address for ctl socket");
}
open_sockt()
{
int length;
my_addr.sin_addr = my_machine_addr;
my_addr.sin_port = 0;
sockt = socket(AF_INET, SOCK_STREAM, 0);
if (sockt <= 0)
p_error("Bad socket");
if (bind(sockt, (struct sockaddr *)&my_addr, sizeof(my_addr)) != 0)
p_error("Binding local socket");
length = sizeof(my_addr);
if (getsockname(sockt, (struct sockaddr *)&my_addr, &length) == -1)
p_error("Bad address for socket");
}
/** Trade edit characters with the other talk. By agreement
* the first three characters each talk transmits after
* connection are the three edit characters.
* A normal talk client uses tcgetattr() to get the chars,
* but the daemon isn't connected to a terminal, so we can't call it.
* We just send dummy chars, to disable control chars. */
void TalkConnection::set_edit_chars()
{
char buf[3];
int cc;
buf[0] = buf[1] = buf[2] = (char)0xff;
/* Write our config to the caller */
cc = write(sockt, buf, sizeof(buf));
if (cc != sizeof(buf) )
p_error("Lost the connection");
/* Read the caller configuration */
cc = read(sockt, buf, sizeof(buf));
if (cc != sizeof(buf) )
p_error("Lost the connection");
char_erase = buf[0]; // store it in TalkConnection
}
/* Lambert Azimuthal Equal Area forward equations--mapping lat,long to x,y
-----------------------------------------------------------------------*/
long lamazfor
(
double lon, /* (I) Longitude */
double lat, /* (I) Latitude */
double *x, /* (O) X projection coordinate */
double *y /* (O) Y projection coordinate */
)
{
double delta_lon; /* Delta longitude (Given longitude - center */
double sin_delta_lon; /* Sine of the delta longitude */
double cos_delta_lon; /* Cosine of the delta longitude */
double sin_lat; /* Sine of the given latitude */
double cos_lat; /* Cosine of the given latitude */
double g; /* temporary varialbe */
double ksp; /* heigth above elipsiod */
char mess[60];
/* Forward equations
-----------------*/
delta_lon = adjust_lon(lon - lon_center);
gctp_sincos(lat, &sin_lat, &cos_lat);
gctp_sincos(delta_lon, &sin_delta_lon, &cos_delta_lon);
g = sin_lat_o * sin_lat + cos_lat_o * cos_lat * cos_delta_lon;
if (g == -1.0)
{
sprintf(mess, "Point projects to a circle of radius = %f\n", 2.0 * R);
p_error(mess, "lamaz-forward");
return(113);
}
ksp = R * sqrt(2.0 / (1.0 + g));
*x = ksp * cos_lat * sin_delta_lon + false_easting;
*y = ksp * (cos_lat_o * sin_lat - sin_lat_o * cos_lat * cos_delta_lon) +
false_northing;
return(GCTP_OK);
}
/* Function to compute the latitude angle, phi2, for the inverse of the
Lambert Conformal Conic and Polar Stereographic projections.
----------------------------------------------------------------*/
double phi2z
(
double eccent, /* Spheroid eccentricity */
double ts, /* Constant value t */
long *flag /* Error flag number */
)
{
double eccnth;
double phi;
double con;
double dphi;
double sinpi;
long i;
*flag = 0;
eccnth = .5 * eccent;
phi = HALF_PI - 2 * atan(ts);
for (i = 0; i <= 15; i++)
{
sinpi = sin(phi);
con = eccent * sinpi;
dphi = HALF_PI - 2 * atan(ts *(pow(((1.0 - con)/(1.0 + con)),eccnth)))
- phi;
phi += dphi;
if (fabs(dphi) <= .0000000001)
return(phi);
}
p_error ("Convergence error","phi2z-conv");
*flag = 002;
return(002);
}
/** Look for an invitation on remote machine */
int TalkConnection::look_for_invite(int mandatory)
{
/* Check for invitation on caller's machine */
ctl_transact(LOOK_UP, 0);
uint8_t answer;
uint32_t id_num;
getResponseItems(&answer, &id_num, &lookup_addr);
if (!mandatory) return 0;
/* the switch is for later options, such as multiple invitations */
switch (answer) {
case SUCCESS:
new_msg.id_num = htonl(id_num);
old_msg.id_num = htonl(id_num);
ktalk_debug("TalkConnection::look_for_invite : got SUCCESS");
if (lookup_addr.ta_family != AF_INET)
p_error("Response uses invalid network address");
return (1);
default:
/* there wasn't an invitation waiting for us */
ktalk_debug("TalkConnection::look_for_invite : didn't get SUCCESS");
return (0);
}
}
/* **************************************************************** */
long utmConversionInit(PointLla point)
{
long zone = 0;
double r_maj = 6378137; // Magic Number: These are the values
double r_min = 6356752.3142; // needed for the UTM ellipsoid
double scale_fact = .9996;
// long val;
if(point->longitudeRadians > PI || point->longitudeRadians < -PI)
{
p_error("Invalid Seed Point for UTM Init. Check Radians??","");
return(-1);
}
zone = calc_utm_zone(point->longitudeRadians*R2D);
// Check if the zone is different than what was done before
if(zone != utmLibZone)
{
if(utmforint(r_maj, r_min, scale_fact, zone) != OK) return -1;
if(utminvint(r_maj, r_min, scale_fact, zone) != OK) return -1;
utmLibInitFlag = 1;
utmLibZone = zone;
return OK;
}
else
{
// Zone is the same, no need to re-init
return OK;
}
}
// Sinusoidal inverse equations--mapping x,y to lat,long
long Projectoid::sininv(
double x, // (I) X projection coordinate
double y, // (I) Y projection coordinate
double *lon, // (O) Longitude
double *lat) // (O) Latitude
{
double temp; // Re-used temporary variable
// Inverse equations
x -= false_easting;
y -= false_northing;
*lat = y / R;
if (fabs(*lat) > HALF_PI)
{
p_error("Input data error", "sinusoidal-inverse");
return(164);
}
temp = fabs(*lat) - HALF_PI;
if (fabs(temp) > EPSLN)
{
temp = lon_center + x / (R * cos(*lat));
*lon = adjust_lon(temp);
}
else
*lon = lon_center;
return(OK);
}
/*
* See if the local daemon has a invitation for us
*/
check_local()
{
CTL_RESPONSE response;
/* the rest of msg was set up in get_names */
msg.ctl_addr = ctl_addr;
/* must be initiating a talk */
if (!look_for_invite(&response))
return (0);
/*
* There was an invitation waiting for us,
* so connect with the other (hopefully waiting) party
*/
current_state = "Waiting to connect with caller";
again:
swapresponse(&response);
if (connect(sockt, &response.addr, sizeof(response.addr)) != -1)
return (1);
if (errno == EINTR)
goto again;
if (errno == ECONNREFUSED) {
/*
* The caller gave up, but his invitation somehow
* was not cleared. Clear it and initiate an
* invitation. (We know there are no newer invitations,
* the talkd works LIFO.)
*/
ctl_transact(his_machine_addr, msg, DELETE, &response);
close(sockt);
open_sockt();
return (0);
}
p_error("Unable to connect with initiator");
/*NOTREACHED*/
}
int is_dir(char *url)
{
struct stat st;
if(stat(url,&st)<0)
p_error("error in is_dir logic error",5);
return S_ISDIR(st.st_mode)?1:0;
}
/* Function to compute latitude, phi3, for the inverse of the Equidistant
Conic projection.
-----------------------------------------------------------------*/
double phi3z
(
double ml, /* Constant */
double e0, /* Constant */
double e1, /* Constant */
double e2, /* Constant */
double e3, /* Constant */
long *flag /* Error flag number */
)
{
double phi;
double dphi;
long i;
phi = ml;
for (i = 0; i < 15; i++)
{
dphi = (ml + e1 * sin(2.0 * phi) - e2 * sin(4.0 * phi) + e3 *
sin(6.0 * phi)) / e0 - phi;
phi += dphi;
if (fabs(dphi) <= .0000000001)
{
*flag = 0;
return(phi);
}
}
p_error("Latitude failed to converge after 15 iterations","PHI3Z-CONV");
*flag = 3;
return(3);
}
/* General Vertical Near-Side Perspective forward equations--mapping
lat,long to x,y
----------------------------------------------------------------*/
long gvnspfor
(
double lon, /* (I) Longitude */
double lat, /* (I) Latitude */
double *x, /* (O) X projection coordinate */
double *y /* (O) Y projection coordinate */
)
{
double dlon;
double sinphi,cosphi;
double coslon;
double g;
double ksp;
/* Forward equations
-----------------*/
dlon = adjust_lon(lon - lon_center);
gctp_sincos(lat,&sinphi,&cosphi);
coslon = cos(dlon);
g = sin_p15 * sinphi + cos_p15 * cosphi * coslon;
if (g < (1.0/ p))
{
p_error("Point cannot be projected","gvnsp-for");
return(153);
}
ksp = (p - 1.0)/(p - g);
*x = false_easting + R * ksp * cosphi * sin(dlon);
*y = false_northing + R * ksp * (cos_p15 * sinphi - sin_p15 * cosphi * coslon);
return(GCTP_OK);
}
/* Wagner IV forward equations--mapping lat,long to x,y
----------------------------------------------------*/
long wivfor
(
double lon, /* (I) Longitude */
double lat, /* (I) Latitude */
double *x, /* (O) X projection coordinate */
double *y /* (O) Y projection coordinate */
)
{
double delta_lon; /* Delta longitude (Given longitude - center */
double theta;
double delta_theta;
double con;
long i;
/* Forward equations
-----------------*/
delta_lon = adjust_lon(lon - lon_center);
theta = lat;
con = 2.9604205062 * sin(lat);
/* Iterate using the Newton-Raphson method to find theta
-----------------------------------------------------*/
for (i=0;;i++)
{
delta_theta = -(theta + sin(theta) - con) / (1.0 + cos(theta));
theta += delta_theta;
if (fabs(delta_theta) < EPSLN) break;
if (i >= 30) p_error("Iteration failed to converge","wagneriv-forward");
}
theta /= 2.0;
*x = 0.86310 * R * delta_lon * cos(theta) + false_easting;
*y = 1.56548 * R * sin(theta) + false_northing;
return(GCTP_OK);
}
/* Universal Transverse Mercator forward equations--mapping lat,long to x,y
Note: The algorithm for UTM is exactly the same as TM and therefore
if a change is implemented, also make the change to TMFOR.c
-----------------------------------------------------------------------*/
long utmfor
(
double lon, /* (I) Longitude */
double lat, /* (I) Latitude */
double *x, /* (O) X projection coordinate */
double *y /* (O) Y projection coordinate */
)
{
double delta_lon; /* Delta longitude (Given longitude - center */
double sin_phi, cos_phi;/* sin and cos value */
double al, als; /* temporary values */
double b; /* temporary values */
double c, t, tq; /* temporary values */
double con, n, ml; /* cone constant, small m */
/* Forward equations
-----------------*/
delta_lon = adjust_lon(lon - lon_center);
gctp_sincos(lat, &sin_phi, &cos_phi);
/* This part was in the fortran code and is for the spherical form
----------------------------------------------------------------*/
if (ind != 0)
{
b = cos_phi * sin(delta_lon);
if ((fabs(fabs(b) - 1.0)) < .0000000001)
{
p_error("Point projects into infinity","utm-for");
return(93);
}
else
{
*x = .5 * r_major * scale_factor * log((1.0 + b)/(1.0 - b));
con = acos(cos_phi * cos(delta_lon)/sqrt(1.0 - b*b));
if (lat < 0)
con = - con;
*y = r_major * scale_factor * (con - lat_origin);
return(GCTP_OK);
}
}
al = cos_phi * delta_lon;
als = SQUARE(al);
c = esp * SQUARE(cos_phi);
tq = tan(lat);
t = SQUARE(tq);
con = 1.0 - es * SQUARE(sin_phi);
n = r_major / sqrt(con);
ml = r_major * mlfn(e0, e1, e2, e3, lat);
*x = scale_factor * n * al * (1.0 + als / 6.0 * (1.0 - t + c + als / 20.0 *
(5.0 - 18.0 * t + SQUARE(t) + 72.0 * c - 58.0 * esp))) + false_easting;
*y = scale_factor * (ml - ml0 + n * tq * (als * (0.5 + als / 24.0 *
(5.0 - t + 9.0 * c + 4.0 * SQUARE(c) + als / 30.0 * (61.0 - 58.0 * t
+ SQUARE(t) + 600.0 * c - 330.0 * esp))))) + false_northing;
return(GCTP_OK);
}
Value* Scope::newVar(const char* n) {
if ( numvar >= MAX_SCOPE_VARS-1 ) {
printf("Scope layer has too much variables: %d [max: %d]\n", numvar, MAX_SCOPE_VARS );
printf("DUMPING SCOPE:\n");
dump();
p_error("DONE");
}
if ( getVar(n) != NULL )
p_error("Variable %s has already been declared in this scope.", n );
Value* res = new Value((long int)0);
val[numvar] = res;
name[numvar] = n;
numvar++;
return res;
}
static void sndcmd(const char *line )
{
char *buf;
if ( (buf=strstr( line, " " )) ) {
gp_tell( port, "%s\n", buf+1 );
} else
p_error( "no command given" );
}
/*
* See if the local daemon has an invitation for us.
*/
int
check_local()
{
CTL_RESPONSE response;
register CTL_RESPONSE *rp = &response;
/* the rest of msg was set up in get_names */
msg.ctl_addr.sa_family = htons (ctl_addr.sin_family);
memcpy (msg.ctl_addr.sa_data,
((struct sockaddr *)&ctl_addr)->sa_data,
sizeof ((struct sockaddr *)&ctl_addr)->sa_data);
/* must be initiating a talk */
if (!look_for_invite(rp))
return (0);
/*
* There was an invitation waiting for us,
* so connect with the other (hopefully waiting) party
*/
current_state = "Waiting to connect with caller";
do {
if (rp->addr.sa_family != AF_INET)
p_error("Response uses invalid network address");
errno = 0;
if (connect(sockt,
(struct sockaddr *)&rp->addr, sizeof (rp->addr)) != -1)
return (1);
} while (errno == EINTR);
if (errno == ECONNREFUSED) {
/*
* The caller gave up, but his invitation somehow
* was not cleared. Clear it and initiate an
* invitation. (We know there are no newer invitations,
* the talkd works LIFO.)
*/
ctl_transact(his_machine_addr, msg, DELETE, rp);
close(sockt);
open_sockt();
return (0);
}
p_error("Unable to connect with initiator");
/*NOTREACHED*/
}
int TalkConnection::open_socket (struct sockaddr_in *addr, int type)
{
addr->sin_family = AF_INET;
addr->sin_addr = my_machine_addr;
addr->sin_port = 0;
int newSocket = socket (PF_INET, type, 0);
if (newSocket <= 0)
p_error ("Unable to open a new socket!");
ksize_t length = sizeof (*addr);
if (bind (newSocket, (struct sockaddr *) addr, length) != 0) {
::close (newSocket);
p_error ("Error binding socket!");
}
if (getsockname (newSocket, (struct sockaddr *) addr, &length) == -1) {
::close (newSocket);
p_error ("New socket has a bad address!");
}
return newSocket;
}
void Context::popscope() {
#ifdef __DEBUG__
printf("Context::popscope\n");
#endif
if ( numscope <= 0 )
p_error("Scope depth underloaded" );
numscope--;
scopes[numscope].clean();
}
/*
* The routine to do the actual talking
*/
void
talk()
{
register int read_template, sockt_mask;
int read_set, nb;
char buf[BUFSIZ];
struct timeval wait;
message("Connection established\007\007\007");
current_line = 0;
sockt_mask = (1<<sockt);
/*
* Wait on both the other process (sockt_mask) and
* standard input ( STDIN_MASK )
*/
read_template = sockt_mask | STDIN_MASK;
forever {
read_set = read_template;
wait.tv_sec = A_LONG_TIME;
wait.tv_usec = 0;
nb = select(32, (fd_set *)&read_set, 0, 0, &wait);
if (nb <= 0) {
if (errno == EINTR) {
read_set = read_template;
continue;
}
/* panic, we don't know what happened */
p_error("Unexpected error from select");
quit();
}
if (read_set & sockt_mask) {
/* There is data on sockt */
nb = read(sockt, buf, sizeof buf);
if (nb <= 0) {
message("Connection closed. Exiting");
quit();
}
display(&his_win, buf, nb);
}
if (read_set & STDIN_MASK) {
/*
* We can't make the tty non_blocking, because
* curses's output routines would screw up
*/
ioctl(0, FIONREAD, (struct sgttyb *) &nb);
nb = read(0, buf, nb);
display(&my_win, buf, nb);
/* might lose data here because sockt is non-blocking */
write(sockt, buf, nb);
}
}
}
/** Accept a connection from another talk client */
int TalkConnection::accept()
{
int accept_sockt;
while ((accept_sockt = ::accept(sockt, 0, 0)) < 0) {
if (errno == EINTR)
continue;
p_error("Unable to connect with your party");
}
::close(sockt);
sockt = accept_sockt;
return sockt;
}
static void padjfi(const char *line )
{
int g;
if ( sscanf( line, "%*s %d", &g )!=EOF ) {
if ( 0 < g && g <= status.curgen ) {
printf( "adjf[i] = %e\n", adjfitnessi( run[g-1].besti ) );
} else
fprintf( stderr, "individual must lie in [1,%d]\n", status.curgen );
} else
p_error( "no individual" );
}
