![]() ![]() | ![]() |
version 1.2, 1999/12/13 01:56:04 | version 1.24, 2001/06/04 02:49:47 | ||
---|---|---|---|
|
|
||
/* $OpenXM: OpenXM_contrib2/asir2000/io/tcpf.c,v 1.1.1.1 1999/12/03 07:39:11 noro Exp $ */ | /* | ||
#if INET | * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED | ||
* All rights reserved. | |||
* | |||
* FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited, | |||
* non-exclusive and royalty-free license to use, copy, modify and | |||
* redistribute, solely for non-commercial and non-profit purposes, the | |||
* computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and | |||
* conditions of this Agreement. For the avoidance of doubt, you acquire | |||
* only a limited right to use the SOFTWARE hereunder, and FLL or any | |||
* third party developer retains all rights, including but not limited to | |||
* copyrights, in and to the SOFTWARE. | |||
* | |||
* (1) FLL does not grant you a license in any way for commercial | |||
* purposes. You may use the SOFTWARE only for non-commercial and | |||
* non-profit purposes only, such as academic, research and internal | |||
* business use. | |||
* (2) The SOFTWARE is protected by the Copyright Law of Japan and | |||
* international copyright treaties. If you make copies of the SOFTWARE, | |||
* with or without modification, as permitted hereunder, you shall affix | |||
* to all such copies of the SOFTWARE the above copyright notice. | |||
* (3) An explicit reference to this SOFTWARE and its copyright owner | |||
* shall be made on your publication or presentation in any form of the | |||
* results obtained by use of the SOFTWARE. | |||
* (4) In the event that you modify the SOFTWARE, you shall notify FLL by | |||
* e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification | |||
* for such modification or the source code of the modified part of the | |||
* SOFTWARE. | |||
* | |||
* THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL | |||
* MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND | |||
* EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS | |||
* FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES' | |||
* RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY | |||
* MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY. | |||
* UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT, | |||
* OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY | |||
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL | |||
* DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES | |||
* ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES | |||
* FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY | |||
* DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF | |||
* SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART | |||
* OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY | |||
* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, | |||
* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. | |||
* $OpenXM: OpenXM_contrib2/asir2000/io/tcpf.c,v 1.23 2000/12/16 07:12:01 noro Exp $ | |||
*/ | |||
#include "ca.h" | #include "ca.h" | ||
#include "parse.h" | #include "parse.h" | ||
#include "com.h" | #include "com.h" | ||
|
|
||
#include "ox.h" | #include "ox.h" | ||
#if defined(VISUAL) | #if defined(VISUAL) | ||
#include <winsock.h> | #include <stdlib.h> | ||
#include <winsock2.h> | |||
#include <process.h> | |||
#endif | #endif | ||
#define OX_XTERM "ox_xterm" | #define OX_XTERM "ox_xterm" | ||
|
|
||
} *m_c_tab; | } *m_c_tab; | ||
static int m_c_i,m_c_s; | static int m_c_i,m_c_s; | ||
int I_am_server; | |||
#if MPI | #if MPI | ||
extern int mpi_nprocs; | extern int mpi_nprocs; | ||
#define valid_mctab_index(ind)\ | #define valid_mctab_index(ind)\ | ||
if((ind)<0||(ind)>=(mpi_nprocs-1)){error("invalid server id");} | if((ind)<0||(ind)>=mpi_nprocs){error("invalid server id");} | ||
#define check_valid_mctab_index(ind)\ | |||
if((ind)<0||(ind)>=mpi_nprocs){(ind)=-1;} | |||
#else | #else | ||
#define valid_mctab_index(ind)\ | #define valid_mctab_index(ind)\ | ||
if((ind)<0||(ind)>=m_c_i||\ | if((ind)<0||(ind)>=m_c_i||\ | ||
(!m_c_tab[ind].m&&!m_c_tab[ind].c)){error("invalid server id");} | ((m_c_tab[ind].m<0)&&(m_c_tab[ind].c<0))){error("invalid server id");} | ||
#define check_valid_mctab_index(ind)\ | |||
if((ind)<0||(ind)>=m_c_i||\ | |||
((m_c_tab[ind].m<0)&&(m_c_tab[ind].c<0))){(ind)=-1;} | |||
#endif | #endif | ||
int register_server(); | int register_server(); | ||
int get_mcindex(int); | int get_mcindex(int); | ||
void Pox_send_raw_cmo(), Pox_recv_raw_cmo(); | |||
void Pox_launch(),Pox_launch_nox(),Pox_launch_main(); | void Pox_launch(),Pox_launch_nox(),Pox_launch_main(); | ||
void Pox_launch_generic(); | void Pox_launch_generic(); | ||
void Pox_shutdown(); | void Pox_shutdown(); | ||
void Pox_rpc(),Pox_cmo_rpc(),Pox_reset(),Pox_sync(),Pox_select(); | void Pox_rpc(),Pox_cmo_rpc(),Pox_reset(),Pox_intr(),Pox_sync(),Pox_select(); | ||
void Pox_push_local(),Pox_push_cmo(),Pox_push_vl(),Pox_push_cmd(); | void Pox_push_local(),Pox_push_cmo(),Pox_push_vl(),Pox_push_cmd(); | ||
|
|
||
void Pgenerate_port(),Ptry_bind_listen(),Ptry_connect(),Ptry_accept(); | void Pgenerate_port(),Ptry_bind_listen(),Ptry_connect(),Ptry_accept(); | ||
void Pregister_server(); | void Pregister_server(); | ||
void Pox_get_serverinfo(); | void Pox_get_serverinfo(); | ||
void Pox_mpi_myid(), Pox_mpi_nprocs(); | |||
void ox_launch_generic(); | void ox_launch_generic(); | ||
pointer bevalf(); | pointer bevalf(); | ||
struct ftab tcp_tab[] = { | struct ftab tcp_tab[] = { | ||
{"ox_send_raw_cmo",Pox_send_raw_cmo,2}, | |||
{"ox_recv_raw_cmo",Pox_recv_raw_cmo,1}, | |||
{"ox_get_serverinfo",Pox_get_serverinfo,-1}, | {"ox_get_serverinfo",Pox_get_serverinfo,-1}, | ||
{"generate_port",Pgenerate_port,-1}, | {"generate_port",Pgenerate_port,-1}, | ||
{"try_bind_listen",Ptry_bind_listen,1}, | {"try_bind_listen",Ptry_bind_listen,1}, | ||
|
|
||
{"ox_cmo_rpc",Pox_cmo_rpc,-99999999}, | {"ox_cmo_rpc",Pox_cmo_rpc,-99999999}, | ||
{"ox_sync",Pox_sync,1}, | {"ox_sync",Pox_sync,1}, | ||
#if MPI | |||
{"ox_mpi_myid",Pox_mpi_myid,0}, | |||
{"ox_mpi_nprocs",Pox_mpi_nprocs,0}, | |||
#endif | |||
#if !MPI | #if !MPI | ||
{"ox_reset",Pox_reset,-2}, | {"ox_reset",Pox_reset,-2}, | ||
{"ox_intr",Pox_intr,1}, | |||
{"ox_select",Pox_select,-2}, | {"ox_select",Pox_select,-2}, | ||
#endif | #endif | ||
|
|
||
{"ox_pop0_local",Pox_pop0_local,1}, | {"ox_pop0_local",Pox_pop0_local,1}, | ||
{"ox_pop_cmo",Pox_pop_cmo,1}, | {"ox_pop_cmo",Pox_pop_cmo,1}, | ||
{"ox_pop0_cmo",Pox_pop0_cmo,1}, | {"ox_pop0_cmo",Pox_pop0_cmo,1}, | ||
{"ox_get",Pox_get,1}, | {"ox_get",Pox_get,-1}, | ||
{"ox_pops",Pox_pops,-2}, | {"ox_pops",Pox_pops,-2}, | ||
{"ox_push_vl",Pox_push_vl,1}, | {"ox_push_vl",Pox_push_vl,1}, | ||
|
|
||
extern struct IOFP iofp[]; | extern struct IOFP iofp[]; | ||
extern MATHCAP my_mathcap; | extern MATHCAP my_mathcap; | ||
extern int ox_exchange_mathcap; | |||
char *getenv(); | char *getenv(); | ||
#if MPI | |||
extern int mpi_myid, mpi_nprocs; | |||
void Pox_mpi_myid(rp) | |||
Q *rp; | |||
{ | |||
STOQ(mpi_myid,*rp); | |||
} | |||
void Pox_mpi_nprocs(rp) | |||
Q *rp; | |||
{ | |||
STOQ(mpi_nprocs,*rp); | |||
} | |||
#endif | |||
void Pox_get_serverinfo(arg,rp) | void Pox_get_serverinfo(arg,rp) | ||
NODE arg; | NODE arg; | ||
LIST *rp; | LIST *rp; | ||
{ | { | ||
int i,c; | int i,c; | ||
Q sid; | Q s_id; | ||
NODE t,n0,n; | NODE t,n0,n; | ||
LIST list,l; | LIST list,l; | ||
if ( !arg ) { | if ( !arg ) { | ||
for ( i = 0, n0 = 0; i < m_c_i; i++ ) | for ( i = 0, n0 = 0; i < m_c_i; i++ ) | ||
if ( m_c_tab[i].m || m_c_tab[i].c ) { | if ( (m_c_tab[i].m>=0) || (m_c_tab[i].c>=0) ) { | ||
c = m_c_tab[i].c; | c = m_c_tab[i].c; | ||
ox_get_serverinfo(c,&list); | ox_get_serverinfo(c,&list); | ||
STOQ(i,sid); | STOQ(i,s_id); | ||
t = mknode(2,sid,list); | t = mknode(2,s_id,list); | ||
MKLIST(l,t); | MKLIST(l,t); | ||
NEXTNODE(n0,n); | NEXTNODE(n0,n); | ||
BDY(n) = (pointer)l; | BDY(n) = (pointer)l; | ||
|
|
||
MKLIST(*rp,n0); | MKLIST(*rp,n0); | ||
} else { | } else { | ||
i = QTOS((Q)ARG0(arg)); | i = QTOS((Q)ARG0(arg)); | ||
if ( i >= 0 && i < m_c_i && (m_c_tab[i].m || m_c_tab[i].c) ) | if ( i >= 0 && i < m_c_i && ((m_c_tab[i].m>=0) || (m_c_tab[i].c>=0)) ) | ||
ox_get_serverinfo(m_c_tab[i].c,rp); | ox_get_serverinfo(m_c_tab[i].c,rp); | ||
else { | else { | ||
MKLIST(*rp,0); | MKLIST(*rp,0); | ||
|
|
||
/* client mode */ | /* client mode */ | ||
cn = get_iofp(cs,cport_str,0); | cn = get_iofp(cs,cport_str,0); | ||
sn = get_iofp(ss,sport_str,0); | sn = get_iofp(ss,sport_str,0); | ||
/* get_iofp returns -1 if the laucher could not spawn the server */ | |||
if ( sn < 0 ) { | |||
/* we should terminate the launcher */ | |||
ox_send_cmd(cn,SM_shutdown); ox_flush_stream_force(cn); | |||
STOQ(-1,*rp); | |||
return; | |||
} | |||
/* register server to the server list */ | /* register server to the server list */ | ||
ind = register_server(use_unix,cn,sn); | ind = register_server(use_unix,cn,sn); | ||
/* request remote mathcap */ | if ( ox_exchange_mathcap ) { | ||
ox_send_cmd(sn,SM_mathcap); | /* request remote mathcap */ | ||
ox_send_cmd(sn,SM_popCMO); | ox_send_cmd(sn,SM_mathcap); | ||
ox_flush_stream_force(sn); | ox_send_cmd(sn,SM_popCMO); | ||
ox_recv(sn,&id,&server_mathcap); | ox_flush_stream_force(sn); | ||
store_remote_mathcap(sn,server_mathcap); | ox_recv(sn,&id,&server_mathcap); | ||
store_remote_mathcap(sn,server_mathcap); | |||
/* send my mathcap */ | |||
create_my_mathcap("asir"); | /* send my mathcap */ | ||
ox_send_data(sn,my_mathcap); | create_my_mathcap("asir"); | ||
ox_send_cmd(sn,SM_setMathcap); | ox_send_data(sn,my_mathcap); | ||
ox_send_cmd(sn,SM_setMathcap); | |||
} | |||
/* return the server id */ | /* return the server id */ | ||
STOQ(ind,*rp); | STOQ(ind,*rp); | ||
} | } | ||
|
|
||
/* client mode */ | /* client mode */ | ||
cn = get_iofp(cs,control_port_str,0); | cn = get_iofp(cs,control_port_str,0); | ||
sn = get_iofp(ss,server_port_str,0); | sn = get_iofp(ss,server_port_str,0); | ||
/* get_iofp returns -1 if the laucher could not spawn the server */ | |||
if ( sn < 0 ) { | |||
/* we should terminate the launcher */ | |||
ox_send_cmd(cn,SM_shutdown); ox_flush_stream_force(cn); | |||
STOQ(-1,*rp); | |||
return; | |||
} | |||
/* register server to the server list */ | /* register server to the server list */ | ||
ind = register_server(use_unix,cn,sn); | ind = register_server(use_unix,cn,sn); | ||
/* request remote mathcap */ | if ( ox_exchange_mathcap ) { | ||
ox_send_cmd(sn,SM_mathcap); | /* request remote mathcap */ | ||
ox_send_cmd(sn,SM_popCMO); | ox_send_cmd(sn,SM_mathcap); | ||
ox_flush_stream_force(sn); | ox_send_cmd(sn,SM_popCMO); | ||
ox_recv(sn,&id,&server_mathcap); | ox_flush_stream_force(sn); | ||
store_remote_mathcap(sn,server_mathcap); | ox_recv(sn,&id,&server_mathcap); | ||
store_remote_mathcap(sn,server_mathcap); | |||
/* send my mathcap */ | |||
create_my_mathcap("asir"); | /* send my mathcap */ | ||
ox_send_data(sn,my_mathcap); | create_my_mathcap("asir"); | ||
ox_send_cmd(sn,SM_setMathcap); | ox_send_data(sn,my_mathcap); | ||
ox_send_cmd(sn,SM_setMathcap); | |||
} | |||
/* return the server id */ | /* return the server id */ | ||
STOQ(ind,*rp); | STOQ(ind,*rp); | ||
} | } | ||
|
|
||
{ | { | ||
char cmd[BUFSIZ]; | char cmd[BUFSIZ]; | ||
char localhost[BUFSIZ]; | char localhost[BUFSIZ]; | ||
char *dname,*conn_str,*rsh; | char *dname,*conn_str,*rsh,*dname0; | ||
char dname_str[BUFSIZ]; | |||
char AsirExe[BUFSIZ]; | |||
STRING rootdir; | |||
char prog[BUFSIZ]; | |||
char *av[BUFSIZ]; | |||
dname = use_x ? (char *)getenv("DISPLAY") : 0; | dname0 = (char *)getenv("DISPLAY"); | ||
if ( !dname0 ) | |||
dname0 = "0"; | |||
dname = use_x ? dname0 : 0; | |||
conn_str = conn_to_serv ? "1" : "0"; | conn_str = conn_to_serv ? "1" : "0"; | ||
rsh = use_ssh ? "ssh" : RSH; | rsh = getenv("ASIR_RSH"); | ||
if ( !rsh ) | |||
rsh = use_ssh ? "ssh" : RSH; | |||
if ( !use_unix && dname && strstr(rsh,"ssh") ) { | |||
/* | |||
* if "ssh" is used to invoke a remote server, | |||
* we should not specify "-display". | |||
*/ | |||
use_ssh = 1; | |||
} | |||
gethostname(localhost,BUFSIZ); | gethostname(localhost,BUFSIZ); | ||
#if defined(VISUAL) | |||
if ( !use_unix ) | |||
error("spawn_server : not implemented on Windows"); | |||
Pget_rootdir(&rootdir); | |||
sprintf(AsirExe,"%s\\bin\\engine.exe",BDY(rootdir)); | |||
strcpy(prog,server); | |||
server = strrchr(prog,'/')+1; | |||
av[0] = "ox_launch"; | |||
av[1] = "127.0.0.1"; | |||
av[2] = conn_str; | |||
av[3] = control_port_str; | |||
av[4] = server_port_str; | |||
av[5] = server; | |||
av[6] = use_x ? "1" : "0"; | |||
av[7] = 0; | |||
_spawnv(_P_NOWAIT,AsirExe,av); | |||
// _spawnv(_P_NOWAIT,"d:\\home\\noro\\engine2000\\debug\\engine.exe",av); | |||
// printf("ox_launch 127.0.0.1 %s %s %s %s 0\n",conn_str,control_port_str,server_port_str,server); | |||
#else | |||
if ( use_unix ) { | if ( use_unix ) { | ||
if ( !fork() ) { | if ( !fork() ) { | ||
setpgid(0,getpid()); | setpgid(0,getpid()); | ||
if ( dname ) | if ( dname ) | ||
execlp("xterm","xterm","-name",OX_XTERM,"-display",dname, | execlp("xterm","xterm","-name",OX_XTERM,"-T","ox_launch:local","-display",dname, | ||
"-geometry","60x10","-e",launcher,".",conn_str, | "-geometry","60x10","-e",launcher,".",conn_str, | ||
control_port_str,server_port_str,server,dname,0); | control_port_str,server_port_str,server,dname,0); | ||
else | else | ||
execlp(launcher,launcher,".",conn_str, | execlp(launcher,launcher,".",conn_str, | ||
control_port_str,server_port_str,server,"0",0); | control_port_str,server_port_str,server,dname0,"-nolog",0); | ||
} | } | ||
} else if ( conn_to_serv == 2 ) { | } else if ( conn_to_serv == 2 ) { | ||
/* special support for java */ | /* special support for java */ | ||
if ( dname ) | if ( dname ) | ||
sprintf(cmd, | sprintf(cmd, | ||
"%s -n %s \"(cd %s; xterm -name %s -display %s -geometry 60x10 -e java %s -host %s -control %s -data %s)>&/dev/null&\">/dev/null", | "%s -n %s \"(cd %s; xterm -name %s %s -geometry 60x10 -e java %s -host %s -control %s -data %s)>&/dev/null&\">/dev/null", | ||
rsh,host,launcher,OX_XTERM,dname,server,localhost,control_port_str,server_port_str); | rsh,host,launcher,OX_XTERM,dname,server,localhost,control_port_str,server_port_str); | ||
else | else | ||
sprintf(cmd, | sprintf(cmd, | ||
|
|
||
/* system(cmd); */ | /* system(cmd); */ | ||
} else { | } else { | ||
if ( dname ) | if ( dname ) | ||
if ( use_ssh ) | |||
sprintf(cmd, | sprintf(cmd, | ||
"%s -n %s \"xterm -name %s -display %s -geometry 60x10 -e %s %s %s %s %s %s %s>&/dev/null&\">/dev/null", | "%s -f -n %s \"xterm -name %s -title ox_launch:%s -geometry 60x10 -e %s %s %s %s %s %s %s >&/dev/null\">/dev/null", | ||
rsh,host,OX_XTERM,dname,launcher,localhost,conn_str, | rsh,host,OX_XTERM,host,launcher,localhost,conn_str, | ||
control_port_str,server_port_str,server,"1"); | |||
else | |||
sprintf(cmd, | |||
"%s -n %s \"xterm -name %s -title ox_launch:%s -display %s -geometry 60x10 -e %s %s %s %s %s %s %s >&/dev/null&\">/dev/null", | |||
rsh,host,OX_XTERM,host,dname,launcher,localhost,conn_str, | |||
control_port_str,server_port_str,server,dname); | control_port_str,server_port_str,server,dname); | ||
else | else | ||
sprintf(cmd, | sprintf(cmd, | ||
"%s -n %s \"%s %s %s %s %s %s %s>&/dev/null&\">/dev/null", | "%s -n %s \"%s %s %s %s %s %s %s %s>&/dev/null&\">/dev/null", | ||
rsh,host,launcher,localhost,conn_str, | rsh,host,launcher,localhost,conn_str, | ||
control_port_str,server_port_str,server,"0"); | control_port_str,server_port_str,server,dname0,"-nolog"); | ||
system(cmd); | system(cmd); | ||
} | } | ||
#endif /* VISUAL */ | |||
} | } | ||
void Pox_launch(arg,rp) | void Pox_launch(arg,rp) | ||
|
|
||
{ | { | ||
int s,i,ci; | int s,i,ci; | ||
struct m_c *t; | struct m_c *t; | ||
#define INIT_TAB_SIZ 64 | |||
if ( c < 0 ) | if ( c < 0 ) | ||
return -1; | return -1; | ||
if ( !m_c_tab ) { | if ( !m_c_tab ) { | ||
s = BUFSIZ*sizeof(struct m_c); | s = INIT_TAB_SIZ*sizeof(struct m_c); | ||
m_c_tab = (struct m_c *)MALLOC_ATOMIC(s); bzero(m_c_tab,s); | m_c_tab = (struct m_c *)MALLOC_ATOMIC(s); | ||
m_c_s = BUFSIZ; | for ( i = 0; i < INIT_TAB_SIZ; i++ ) { | ||
m_c_tab[i].af_unix = 0; | |||
m_c_tab[i].m = m_c_tab[i].c = -1; | |||
} | |||
m_c_s = INIT_TAB_SIZ; | |||
} | } | ||
#if !MPI | #if !MPI | ||
for ( i = 0; i < m_c_i; i++ ) | for ( i = 0; i < m_c_i; i++ ) | ||
if ( !m_c_tab[i].m && !m_c_tab[i].c ) | if ( (m_c_tab[i].m<0) && (m_c_tab[i].c<0) ) | ||
break; | break; | ||
if ( i < m_c_i ) { | if ( i < m_c_i ) { | ||
m_c_tab[i].m = m; m_c_tab[i].c = c; | m_c_tab[i].m = m; m_c_tab[i].c = c; | ||
|
|
||
} | } | ||
#endif | #endif | ||
if ( m_c_i == m_c_s ) { | if ( m_c_i == m_c_s ) { | ||
s = (m_c_s+BUFSIZ)*sizeof(struct m_c); | s = (m_c_s+INIT_TAB_SIZ)*sizeof(struct m_c); | ||
t = (struct m_c *)MALLOC_ATOMIC(s); bzero(m_c_tab,s); | t = (struct m_c *)MALLOC_ATOMIC(s); bzero(m_c_tab,s); | ||
bcopy(m_c_tab,t,m_c_s*sizeof(struct m_c)); | bcopy(m_c_tab,t,m_c_s*sizeof(struct m_c)); | ||
m_c_s += BUFSIZ; m_c_tab = t; | for ( i = 0; i < INIT_TAB_SIZ; i++ ) { | ||
m_c_tab[m_c_s+i].af_unix = 0; | |||
m_c_tab[m_c_s+i].m = m_c_tab[m_c_s+i].c = -1; | |||
} | |||
m_c_s += INIT_TAB_SIZ; m_c_tab = t; | |||
} | } | ||
m_c_tab[m_c_i].m = m; m_c_tab[m_c_i].c = c; | m_c_tab[m_c_i].m = m; m_c_tab[m_c_i].c = c; | ||
m_c_tab[m_c_i].af_unix = af_unix; | m_c_tab[m_c_i].af_unix = af_unix; | ||
|
|
||
*rp = ONE; | *rp = ONE; | ||
} | } | ||
void Pox_send_raw_cmo(arg,rp) | |||
NODE arg; | |||
Obj *rp; | |||
{ | |||
int s; | |||
int index = QTOS((Q)ARG0(arg)); | |||
valid_mctab_index(index); | |||
s = m_c_tab[index].c; | |||
ox_write_cmo(s,(Obj)ARG1(arg)); | |||
/* flush always */ | |||
ox_flush_stream(s); | |||
*rp = 0; | |||
} | |||
void Pox_recv_raw_cmo(arg,rp) | |||
NODE arg; | |||
Obj *rp; | |||
{ | |||
int s; | |||
int index = QTOS((Q)ARG0(arg)); | |||
valid_mctab_index(index); | |||
s = m_c_tab[index].c; | |||
ox_read_cmo(s,rp); | |||
} | |||
void Pox_push_local(arg,rp) | void Pox_push_local(arg,rp) | ||
NODE arg; | NODE arg; | ||
Obj *rp; | Obj *rp; | ||
|
|
||
NODE arg; | NODE arg; | ||
Obj *rp; | Obj *rp; | ||
{ | { | ||
int index = QTOS((Q)ARG0(arg)); | int index; | ||
int s; | int s; | ||
valid_mctab_index(index); | if ( !arg ) { | ||
s = m_c_tab[index].c; | /* client->server */ | ||
ox_flush_stream_force(s); | ox_get_result(0,rp); | ||
ox_get_result(s,rp); | } else { | ||
/* server->client */ | |||
index = QTOS((Q)ARG0(arg)); | |||
valid_mctab_index(index); | |||
s = m_c_tab[index].c; | |||
ox_flush_stream_force(s); | |||
ox_get_result(s,rp); | |||
} | |||
} | } | ||
void Pox_pops(arg,rp) | void Pox_pops(arg,rp) | ||
|
|
||
*rp = 0; | *rp = 0; | ||
} | } | ||
void Pox_intr(arg,rp) | |||
NODE arg; | |||
Q *rp; | |||
{ | |||
int m; | |||
Obj obj; | |||
int index = QTOS((Q)ARG0(arg)); | |||
valid_mctab_index(index); | |||
m = m_c_tab[index].m; | |||
if ( m >= 0 ) { | |||
if ( argc(arg) == 1 ) { | |||
ox_send_cmd(m,SM_control_intr); | |||
ox_flush_stream_force(m); | |||
} | |||
*rp = ONE; | |||
} else | |||
*rp = 0; | |||
} | |||
void Pox_sync(arg,rp) | void Pox_sync(arg,rp) | ||
NODE arg; | NODE arg; | ||
Q *rp; | Q *rp; | ||
|
|
||
s = m_c_tab[index].m; | s = m_c_tab[index].m; | ||
ox_send_cmd(s,SM_shutdown); | ox_send_cmd(s,SM_shutdown); | ||
free_iofp(s); | free_iofp(s); | ||
#if !defined(VISUAL) | |||
s = m_c_tab[index].c; | |||
free_iofp(s); | |||
#endif | |||
#if !MPI && !defined(VISUAL) | #if !MPI && !defined(VISUAL) | ||
if ( m_c_tab[index].af_unix ) | if ( m_c_tab[index].af_unix ) | ||
wait(&status); | wait(&status); | ||
#endif | #endif | ||
m_c_tab[index].m = 0; m_c_tab[index].c = 0; | m_c_tab[index].m = -1; m_c_tab[index].c = -1; | ||
m_c_tab[index].af_unix = 0; | m_c_tab[index].af_unix = 0; | ||
*rp = 0; | *rp = 0; | ||
} | } | ||
|
|
||
NODE arg; | NODE arg; | ||
Q *rp; | Q *rp; | ||
{ | { | ||
unsigned int ui; | int ui; | ||
int index = QTOS((Q)ARG0(arg)); | int index = QTOS((Q)ARG0(arg)); | ||
valid_mctab_index(index); | valid_mctab_index(index); | ||
ui = (unsigned int)QTOS((Q)ARG1(arg)); | ui = QTOS((Q)ARG1(arg)); | ||
ox_send_cmd(m_c_tab[index].c,ui); | ox_send_cmd(m_c_tab[index].c,ui); | ||
*rp = 0; | *rp = 0; | ||
} | } | ||
void shutdown_all() { | |||
int s; | |||
int i,index; | |||
int status; | |||
for ( i = I_am_server?1:0; i < m_c_i; i++ ) { | |||
index = i; | |||
check_valid_mctab_index(index); | |||
if ( index < 0 ) | |||
continue; | |||
s = m_c_tab[index].m; | |||
ox_send_cmd(s,SM_shutdown); | |||
#if defined(VISUAL) | |||
Sleep(1000); | |||
#endif | #endif | ||
free_iofp(s); | |||
#if !defined(VISUAL) | |||
s = m_c_tab[index].c; | |||
free_iofp(s); | |||
#endif | |||
#if !MPI && !defined(VISUAL) | |||
if ( m_c_tab[index].af_unix ) | |||
wait(&status); | |||
#endif | |||
m_c_tab[index].m = 0; m_c_tab[index].c = 0; | |||
m_c_tab[index].af_unix = 0; | |||
} | |||
} |