[BACK]Return to tcpf.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / io

Annotation of OpenXM_contrib2/asir2000/io/tcpf.c, Revision 1.29

1.10      noro        1: /*
                      2:  * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
                      3:  * All rights reserved.
                      4:  *
                      5:  * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
                      6:  * non-exclusive and royalty-free license to use, copy, modify and
                      7:  * redistribute, solely for non-commercial and non-profit purposes, the
                      8:  * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
                      9:  * conditions of this Agreement. For the avoidance of doubt, you acquire
                     10:  * only a limited right to use the SOFTWARE hereunder, and FLL or any
                     11:  * third party developer retains all rights, including but not limited to
                     12:  * copyrights, in and to the SOFTWARE.
                     13:  *
                     14:  * (1) FLL does not grant you a license in any way for commercial
                     15:  * purposes. You may use the SOFTWARE only for non-commercial and
                     16:  * non-profit purposes only, such as academic, research and internal
                     17:  * business use.
                     18:  * (2) The SOFTWARE is protected by the Copyright Law of Japan and
                     19:  * international copyright treaties. If you make copies of the SOFTWARE,
                     20:  * with or without modification, as permitted hereunder, you shall affix
                     21:  * to all such copies of the SOFTWARE the above copyright notice.
                     22:  * (3) An explicit reference to this SOFTWARE and its copyright owner
                     23:  * shall be made on your publication or presentation in any form of the
                     24:  * results obtained by use of the SOFTWARE.
                     25:  * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
1.11      noro       26:  * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
1.10      noro       27:  * for such modification or the source code of the modified part of the
                     28:  * SOFTWARE.
                     29:  *
                     30:  * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
                     31:  * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
                     32:  * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
                     33:  * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
                     34:  * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
                     35:  * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
                     36:  * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
                     37:  * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
                     38:  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
                     39:  * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
                     40:  * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
                     41:  * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
                     42:  * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
                     43:  * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
                     44:  * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
                     45:  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
                     46:  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
1.29    ! noro       47:  * $OpenXM: OpenXM_contrib2/asir2000/io/tcpf.c,v 1.28 2001/12/25 05:28:39 noro Exp $
1.10      noro       48: */
1.1       noro       49: #include "ca.h"
                     50: #include "parse.h"
                     51: #include "com.h"
                     52: #include <signal.h>
1.27      noro       53: #include <string.h>
1.1       noro       54: #if !defined(VISUAL)
1.28      noro       55: #include <unistd.h>
1.1       noro       56: #include <sys/types.h>
                     57: #include <pwd.h>
                     58: #endif
                     59: #include "ox.h"
                     60:
                     61: #if defined(VISUAL)
1.15      noro       62: #include <stdlib.h>
1.19      noro       63: #include <winsock2.h>
1.15      noro       64: #include <process.h>
1.1       noro       65: #endif
                     66:
                     67: #define OX_XTERM "ox_xterm"
                     68:
                     69: #if !defined(_PA_RISC1_1)
                     70: #define RSH "rsh"
                     71: #else
                     72: #define RSH "remsh"
                     73: #endif
                     74:
                     75: static struct m_c {
                     76:        int m,c,af_unix;
                     77: } *m_c_tab;
                     78:
                     79: static int m_c_i,m_c_s;
1.16      noro       80: int I_am_server;
1.1       noro       81:
                     82: #if MPI
                     83: extern int mpi_nprocs;
                     84: #define valid_mctab_index(ind)\
1.8       noro       85: if((ind)<0||(ind)>=mpi_nprocs){error("invalid server id");}
1.16      noro       86: #define check_valid_mctab_index(ind)\
                     87: if((ind)<0||(ind)>=mpi_nprocs){(ind)=-1;}
1.1       noro       88: #else
                     89: #define valid_mctab_index(ind)\
                     90: if((ind)<0||(ind)>=m_c_i||\
1.8       noro       91: ((m_c_tab[ind].m<0)&&(m_c_tab[ind].c<0))){error("invalid server id");}
1.16      noro       92: #define check_valid_mctab_index(ind)\
                     93: if((ind)<0||(ind)>=m_c_i||\
                     94: ((m_c_tab[ind].m<0)&&(m_c_tab[ind].c<0))){(ind)=-1;}
1.1       noro       95: #endif
                     96:
                     97: int register_server();
                     98: int get_mcindex(int);
                     99:
1.8       noro      100: void Pox_send_raw_cmo(), Pox_recv_raw_cmo();
                    101:
1.26      noro      102: void Pox_launch(),Pox_launch_nox();
1.1       noro      103: void Pox_launch_generic();
                    104: void Pox_shutdown();
                    105:
1.5       noro      106: void Pox_rpc(),Pox_cmo_rpc(),Pox_reset(),Pox_intr(),Pox_sync(),Pox_select();
1.1       noro      107:
                    108: void Pox_push_local(),Pox_push_cmo(),Pox_push_vl(),Pox_push_cmd();
                    109:
                    110: void Pox_pop_local(),Pox_pop_cmo();
                    111: void Pox_pop0_local(),Pox_pop0_cmo();
                    112: void Pox_pop_string(),Pox_pop0_string();
                    113: void Pox_get(),Pox_pops();
                    114:
                    115: void Pox_execute_function(),Pox_execute_string();
                    116: void Pox_setname(), Pox_evalname();
                    117: void Pox_flush();
                    118: void Pgenerate_port(),Ptry_bind_listen(),Ptry_connect(),Ptry_accept();
                    119: void Pregister_server();
                    120: void Pox_get_serverinfo();
1.8       noro      121: void Pox_mpi_myid(), Pox_mpi_nprocs();
1.1       noro      122:
                    123: void ox_launch_generic();
                    124:
                    125: pointer bevalf();
                    126:
                    127: struct ftab tcp_tab[] = {
1.8       noro      128:        {"ox_send_raw_cmo",Pox_send_raw_cmo,2},
                    129:        {"ox_recv_raw_cmo",Pox_recv_raw_cmo,1},
1.1       noro      130:        {"ox_get_serverinfo",Pox_get_serverinfo,-1},
                    131:        {"generate_port",Pgenerate_port,-1},
                    132:        {"try_bind_listen",Ptry_bind_listen,1},
                    133:        {"try_connect",Ptry_connect,2},
                    134:        {"try_accept",Ptry_accept,2},
                    135:        {"register_server",Pregister_server,4},
                    136:        {"ox_flush",Pox_flush,1},
                    137:        {"ox_launch",Pox_launch,-3},
                    138:        {"ox_launch_nox",Pox_launch_nox,-3},
                    139:        {"ox_launch_generic",Pox_launch_generic,7},
                    140:        {"ox_shutdown",Pox_shutdown,1},
                    141:
                    142:        {"ox_rpc",Pox_rpc,-99999999},
                    143:        {"ox_cmo_rpc",Pox_cmo_rpc,-99999999},
                    144:
                    145:        {"ox_sync",Pox_sync,1},
1.8       noro      146: #if MPI
                    147:        {"ox_mpi_myid",Pox_mpi_myid,0},
                    148:        {"ox_mpi_nprocs",Pox_mpi_nprocs,0},
                    149: #endif
1.1       noro      150: #if !MPI
                    151:        {"ox_reset",Pox_reset,-2},
1.5       noro      152:        {"ox_intr",Pox_intr,1},
1.1       noro      153:        {"ox_select",Pox_select,-2},
                    154: #endif
                    155:
                    156:        {"ox_pop_string",Pox_pop_string,1},
                    157:        {"ox_pop0_string",Pox_pop0_string,1},
                    158:        {"ox_pop_local",Pox_pop_local,1},
                    159:        {"ox_pop0_local",Pox_pop0_local,1},
                    160:        {"ox_pop_cmo",Pox_pop_cmo,1},
                    161:        {"ox_pop0_cmo",Pox_pop0_cmo,1},
1.3       noro      162:        {"ox_get",Pox_get,-1},
1.1       noro      163:        {"ox_pops",Pox_pops,-2},
                    164:
                    165:        {"ox_push_vl",Pox_push_vl,1},
                    166:        {"ox_push_local",Pox_push_local,-99999999},
                    167:        {"ox_push_cmo",Pox_push_cmo,-99999999},
                    168:        {"ox_push_cmd",Pox_push_cmd,2},
                    169:
                    170:        {"ox_setname",Pox_setname,2},
                    171:        {"ox_evalname",Pox_evalname,2},
                    172:
                    173:        {"ox_execute_string",Pox_execute_string,2},
                    174:        {"ox_execute_function",Pox_execute_function,3},
                    175:
                    176:
                    177:        {0,0,0},
                    178: };
                    179:
                    180: extern struct IOFP iofp[];
                    181: extern MATHCAP my_mathcap;
1.6       noro      182: extern int ox_exchange_mathcap;
1.1       noro      183:
                    184: char *getenv();
                    185:
1.8       noro      186: #if MPI
                    187: extern int mpi_myid, mpi_nprocs;
                    188:
1.26      noro      189: void Pox_mpi_myid(Q *rp)
1.8       noro      190: {
                    191:        STOQ(mpi_myid,*rp);
                    192: }
                    193:
1.26      noro      194: void Pox_mpi_nprocs(Q *rp)
1.8       noro      195: {
                    196:        STOQ(mpi_nprocs,*rp);
                    197: }
                    198: #endif
                    199:
1.26      noro      200: void Pox_get_serverinfo(NODE arg,LIST *rp)
1.1       noro      201: {
                    202:        int i,c;
1.24      noro      203:        Q s_id;
1.1       noro      204:        NODE t,n0,n;
                    205:        LIST list,l;
                    206:
                    207:        if ( !arg ) {
                    208:                for ( i = 0, n0 = 0; i < m_c_i; i++ )
1.8       noro      209:                        if ( (m_c_tab[i].m>=0) || (m_c_tab[i].c>=0) ) {
1.1       noro      210:                                c = m_c_tab[i].c;
                    211:                                ox_get_serverinfo(c,&list);
1.24      noro      212:                                STOQ(i,s_id);
                    213:                                t = mknode(2,s_id,list);
1.1       noro      214:                                MKLIST(l,t);
                    215:                                NEXTNODE(n0,n);
                    216:                                BDY(n) = (pointer)l;
                    217:                        }
                    218:                if ( n0 )
                    219:                        NEXT(n) = 0;
                    220:                MKLIST(*rp,n0);
                    221:        } else {
                    222:                i = QTOS((Q)ARG0(arg));
1.8       noro      223:                if ( i >= 0 && i < m_c_i && ((m_c_tab[i].m>=0) || (m_c_tab[i].c>=0)) )
1.1       noro      224:                        ox_get_serverinfo(m_c_tab[i].c,rp);
                    225:                else {
                    226:                        MKLIST(*rp,0);
                    227:                }
                    228:        }
                    229: }
                    230:
                    231: /*
                    232:   if noarg or arg[0]==0 then use IP socket and return a port number
                    233:   else use UNIX socket and return a string which represents a path name
                    234: */
                    235:
1.26      noro      236: void Pgenerate_port(NODE arg,Obj *rp)
1.1       noro      237: {
                    238:        char port_str[BUFSIZ];
                    239:        int port;
                    240:        char *s;
                    241:        STRING str;
                    242:        Q q;
                    243:
                    244:        if ( !arg || !ARG0(arg) ) {
                    245:                generate_port(0,port_str);
                    246:                port = atoi(port_str);
                    247:                STOQ(port,q);
                    248:                *rp = (Obj)q;
                    249:        } else {
                    250:                generate_port(1,port_str);
1.26      noro      251:                s = (char *)MALLOC(strlen((char *)port_str)+1);
1.1       noro      252:                strcpy(s,port_str);
                    253:                MKSTR(str,s);
                    254:                *rp = (Obj)str;
                    255:        }
                    256: }
                    257:
                    258: /*
                    259:  try_bind_listen(port)
                    260: */
                    261:
1.26      noro      262: void Ptry_bind_listen(NODE arg,Q *rp)
1.1       noro      263: {
                    264:        char port_str[BUFSIZ];
                    265:        int port,s,use_unix;
                    266:
1.28      noro      267:        if ( IS_CYGWIN || !ARG0(arg) || NUM(ARG0(arg)) ) {
1.1       noro      268:                port = QTOS((Q)ARG0(arg));
                    269:                sprintf(port_str,"%d",port);
                    270:                use_unix = 0;
                    271:        } else {
                    272:                strcpy(port_str,BDY((STRING)ARG0(arg)));
                    273:                use_unix = 1;
                    274:        }
                    275:        s = try_bind_listen(use_unix,port_str);
                    276:        STOQ(s,*rp);
                    277: }
                    278:
                    279: /*
                    280:  try_connect(host,port)
                    281: */
                    282:
1.26      noro      283: void Ptry_connect(NODE arg,Q *rp)
1.1       noro      284: {
                    285:        char port_str[BUFSIZ];
                    286:        char *host;
                    287:        int port,s,use_unix;
                    288:
1.28      noro      289:        if ( IS_CYGWIN || !ARG1(arg) || NUM(ARG1(arg)) ) {
1.1       noro      290:                port = QTOS((Q)ARG1(arg));
                    291:                sprintf(port_str,"%d",port);
                    292:                use_unix = 0;
                    293:        } else {
                    294:                strcpy(port_str,BDY((STRING)ARG1(arg)));
                    295:                use_unix = 1;
                    296:        }
                    297:        host = BDY((STRING)ARG0(arg));
                    298:        s = try_connect(use_unix,host,port_str);
                    299:        STOQ(s,*rp);
                    300: }
                    301:
                    302: /*
                    303:  try_accept(sock,port)
                    304: */
                    305:
1.26      noro      306: void Ptry_accept(NODE arg,Q *rp)
1.1       noro      307: {
                    308:        int use_unix,s;
                    309:
1.28      noro      310:        if ( IS_CYGWIN || !ARG1(arg) || NUM(ARG1(arg)) )
1.1       noro      311:                use_unix = 0;
                    312:        else
                    313:                use_unix = 1;
                    314:        s = try_accept(use_unix,QTOS((Q)ARG0(arg)));
                    315:        STOQ(s,*rp);
                    316: }
                    317:
                    318: /*
                    319:  register_server(cs,cport,ss,sport)
                    320: */
                    321:
1.26      noro      322: void Pregister_server(NODE arg,Q *rp)
1.1       noro      323: {
                    324:        int cs,ss,cn,sn,ind,use_unix,id;
                    325:        char cport_str[BUFSIZ],sport_str[BUFSIZ];
1.26      noro      326:        Obj obj;
1.1       noro      327:        MATHCAP server_mathcap;
                    328:
                    329:        cs = QTOS((Q)ARG0(arg));
                    330:        ss = QTOS((Q)ARG2(arg));
1.28      noro      331:        if ( IS_CYGWIN || !ARG1(arg) || NUM(ARG1(arg)) ) {
1.1       noro      332:                sprintf(cport_str,"%d",QTOS((Q)ARG1(arg)));
                    333:                use_unix = 0;
                    334:        } else {
                    335:                strcpy(cport_str,BDY((STRING)ARG1(arg)));
                    336:                use_unix = 1;
                    337:        }
                    338:        if ( !ARG3(arg) || NUM(ARG3(arg)) ) {
                    339:                if ( use_unix )
                    340:                        error("register_server : the protocol should conincide for two sockets");
                    341:                sprintf(sport_str,"%d",QTOS((Q)ARG3(arg)));
                    342:        } else {
                    343:                if ( !use_unix )
                    344:                        error("register_server : the protocol should conincide for two sockets");
                    345:                strcpy(sport_str,BDY((STRING)ARG3(arg)));
                    346:        }
                    347:
                    348:        /* client mode */
                    349:        cn = get_iofp(cs,cport_str,0);
                    350:        sn = get_iofp(ss,sport_str,0);
1.12      noro      351:        /* get_iofp returns -1 if the laucher could not spawn the server */
                    352:        if ( sn < 0 ) {
                    353:                /* we should terminate the launcher */
                    354:                ox_send_cmd(cn,SM_shutdown); ox_flush_stream_force(cn);
                    355:                STOQ(-1,*rp);
                    356:                return;
                    357:        }
1.1       noro      358:
                    359:        /* register server to the server list */
                    360:        ind = register_server(use_unix,cn,sn);
                    361:
1.6       noro      362:        if ( ox_exchange_mathcap ) {
                    363:                /* request remote mathcap */
                    364:                ox_send_cmd(sn,SM_mathcap);
                    365:                ox_send_cmd(sn,SM_popCMO);
                    366:                ox_flush_stream_force(sn);
1.26      noro      367:                ox_recv(sn,&id,&obj); server_mathcap = (MATHCAP)obj;
1.6       noro      368:                store_remote_mathcap(sn,server_mathcap);
                    369:
                    370:                /* send my mathcap */
                    371:                create_my_mathcap("asir");
                    372:                ox_send_data(sn,my_mathcap);
                    373:                ox_send_cmd(sn,SM_setMathcap);
                    374:        }
1.1       noro      375:        /* return the server id */
                    376:        STOQ(ind,*rp);
                    377: }
                    378:
                    379: /*
                    380:   ox_launch_generic(host,launcher,server,use_unix,use_ssh,use_x,conn_to_serv)
                    381:
                    382:   Input
                    383:        host: hostname on which servers run
                    384:        launcher: path name of the launcher
                    385:        server: path name of the server
                    386:        use_unix: use UNIX domain socket if 1
                    387:        use_ssh: use ssh if 1
                    388:        use_x: use X11 facilities if 1
                    389:        conn_to_serv: connect to server if 1
                    390: */
                    391:
1.26      noro      392: void Pox_launch_generic(NODE arg,Q *rp)
1.1       noro      393: {
                    394:        int use_unix,use_ssh,use_x,conn_to_serv;
                    395:        char *host,*launcher,*server;
1.26      noro      396:        Q ret;
1.1       noro      397:
                    398:        host = (arg&&ARG0(arg))?BDY((STRING)ARG0(arg)):0;
                    399:        launcher = BDY((STRING)ARG1(arg));
                    400:        server = BDY((STRING)ARG2(arg));
1.28      noro      401:        use_unix = !IS_CYGWIN && ARG3(arg) ? 1 : 0;
1.1       noro      402:        use_ssh = ARG4(arg) ? 1 : 0;
                    403:        use_x = ARG5(arg) ? 1 : 0;
                    404:        conn_to_serv = QTOS((Q)ARG6(arg));
1.28      noro      405:        if ( !IS_CYGWIN && !host )
1.1       noro      406:                use_unix = 1;
                    407:        ox_launch_generic(host,launcher,server,
1.26      noro      408:                use_unix,use_ssh,use_x,conn_to_serv,&ret);
                    409:        *rp = ret;
1.1       noro      410: }
                    411:
1.26      noro      412: void ox_launch_generic(char *host,char *launcher,char *server,
                    413:                int use_unix,int use_ssh,int use_x,int conn_to_serv,Q *rp)
1.1       noro      414: {
                    415:        int cs,ss,cn,sn,ind,id;
                    416:        char control_port_str[BUFSIZ];
                    417:        char server_port_str[BUFSIZ];
1.26      noro      418:        Obj obj;
1.1       noro      419:        MATHCAP server_mathcap;
                    420:
                    421:        control_port_str[0] = 0;
                    422:        server_port_str[0] = 0;
                    423:        do {
                    424:                generate_port(use_unix,control_port_str);
                    425:                generate_port(use_unix,server_port_str);
                    426:                if ( !conn_to_serv ) {
                    427:                        cs = try_bind_listen(use_unix,control_port_str);
                    428:                        ss = try_bind_listen(use_unix,server_port_str);
                    429:                }
                    430:                spawn_server(host,launcher,server,
                    431:                        use_unix,use_ssh,use_x,conn_to_serv,
                    432:                                control_port_str,server_port_str);
                    433:                if ( conn_to_serv ) {
                    434:                        cs = try_connect(use_unix,host,control_port_str);
                    435:                        ss = try_connect(use_unix,host,server_port_str);
                    436:                } else {
                    437:                        cs = try_accept(use_unix,cs);
                    438:                        ss = try_accept(use_unix,ss);
                    439:                }
                    440:        } while ( cs < 0 || ss < 0 );
                    441:
                    442:        /* client mode */
                    443:        cn = get_iofp(cs,control_port_str,0);
                    444:        sn = get_iofp(ss,server_port_str,0);
1.12      noro      445:        /* get_iofp returns -1 if the laucher could not spawn the server */
                    446:        if ( sn < 0 ) {
                    447:                /* we should terminate the launcher */
                    448:                ox_send_cmd(cn,SM_shutdown); ox_flush_stream_force(cn);
                    449:                STOQ(-1,*rp);
                    450:                return;
                    451:        }
1.1       noro      452:
                    453:        /* register server to the server list */
                    454:        ind = register_server(use_unix,cn,sn);
                    455:
1.6       noro      456:        if ( ox_exchange_mathcap ) {
                    457:                /* request remote mathcap */
                    458:                ox_send_cmd(sn,SM_mathcap);
                    459:                ox_send_cmd(sn,SM_popCMO);
                    460:                ox_flush_stream_force(sn);
1.26      noro      461:                ox_recv(sn,&id,&obj); server_mathcap = (MATHCAP)obj;
1.6       noro      462:                store_remote_mathcap(sn,server_mathcap);
                    463:
                    464:                /* send my mathcap */
                    465:                create_my_mathcap("asir");
                    466:                ox_send_data(sn,my_mathcap);
                    467:                ox_send_cmd(sn,SM_setMathcap);
                    468:        }
1.1       noro      469:        /* return the server id */
                    470:        STOQ(ind,*rp);
                    471: }
                    472:
1.28      noro      473: #if defined(__CYGWIN__)
1.29    ! noro      474: static void bslash2slash(char *buf)
        !           475: {
        !           476:        char *p;
        !           477:
        !           478:        for ( p = buf; *p; p++ )
        !           479:                if ( *p == '\\' )
        !           480:                        *p = '/';
        !           481: }
        !           482:
1.28      noro      483: static int get_start_path(char *buf)
                    484: {
                    485:        static char start_path[BUFSIZ];
                    486:        static int start_initialized = 0;
                    487:        char name[BUFSIZ];
                    488:
                    489:        if ( start_initialized ) {
                    490:                strcpy(buf,start_path);
                    491:                return 1;
                    492:        }
                    493:
                    494:        /* Windows2000 */
                    495:        strcpy(buf,"c:\\winnt\\system32\\start.exe");
                    496:        cygwin_conv_to_full_posix_path(buf,name);
                    497:        if ( !access(name,X_OK) ) {
1.29    ! noro      498:                bslash2slash(buf);
1.28      noro      499:                strcpy(start_path,buf);
                    500:                return 1;
                    501:        }
                    502:
                    503:        /* Windows98 */
                    504:        strcpy(buf,"c:\\windows\\command\\start.exe");
                    505:        cygwin_conv_to_full_posix_path(buf,name);
                    506:        if ( !access(name,X_OK) ) {
1.29    ! noro      507:                bslash2slash(buf);
1.28      noro      508:                strcpy(start_path,buf);
                    509:                return 1;
                    510:        }
                    511:
                    512:        return 0;
                    513: }
                    514:
                    515: static void get_launcher_path(char *buf)
                    516: {
                    517:        static char rootname[BUFSIZ];
                    518:        static char launcher_path[BUFSIZ];
                    519:        static int launcher_initialized = 0;
                    520:        char name[BUFSIZ];
                    521:
                    522:        if ( launcher_initialized ) {
                    523:                strcpy(buf,launcher_path);
                    524:                return;
                    525:        }
                    526:
                    527:        get_rootdir(rootname,sizeof(rootname));
                    528:        sprintf(name,"%s/ox_launch.exe",rootname);
                    529:        cygwin_conv_to_full_win32_path(name,launcher_path);
1.29    ! noro      530:        bslash2slash(launcher_path);
1.28      noro      531:        launcher_initialized = 1;
                    532:        strcpy(buf,launcher_path);
                    533: }
                    534: #endif
                    535:
1.26      noro      536: void spawn_server(char *host,char *launcher,char *server,
                    537:        int use_unix,int use_ssh,int use_x,int conn_to_serv,
                    538:        char *control_port_str,char *server_port_str)
1.1       noro      539: {
                    540:        char localhost[BUFSIZ];
1.17      noro      541:        char *dname,*conn_str,*rsh,*dname0;
1.15      noro      542:        char AsirExe[BUFSIZ];
                    543:        STRING rootdir;
                    544:        char prog[BUFSIZ];
                    545:        char *av[BUFSIZ];
1.26      noro      546: #if !defined(VISUAL)
                    547:        char cmd[BUFSIZ];
                    548: #endif
1.28      noro      549: #if defined(__CYGWIN__)
                    550:        char win_start[BUFSIZ],win_launcher[BUFSIZ];
                    551: #endif
1.26      noro      552:        void Pget_rootdir();
1.1       noro      553:
1.17      noro      554:        dname0 = (char *)getenv("DISPLAY");
1.23      noro      555:        if ( !dname0 )
                    556:                dname0 = "0";
1.17      noro      557:        dname = use_x ? dname0 : 0;
1.1       noro      558:        conn_str = conn_to_serv ? "1" : "0";
1.13      noro      559:        rsh = getenv("ASIR_RSH");
                    560:        if ( !rsh )
                    561:                rsh = use_ssh ? "ssh" : RSH;
1.25      noro      562:        if ( !use_unix && strstr(rsh,"ssh") ) {
1.13      noro      563:                /*
                    564:                 * if "ssh" is used to invoke a remote server,
                    565:                 * we should not specify "-display".
                    566:                 */
                    567:                use_ssh = 1;
                    568:        }
1.1       noro      569:        gethostname(localhost,BUFSIZ);
1.15      noro      570: #if defined(VISUAL)
                    571:        if ( !use_unix )
                    572:                error("spawn_server : not implemented on Windows");
                    573:        Pget_rootdir(&rootdir);
                    574:        sprintf(AsirExe,"%s\\bin\\engine.exe",BDY(rootdir));
                    575:        strcpy(prog,server);
                    576:        server = strrchr(prog,'/')+1;
                    577:        av[0] = "ox_launch";
                    578:        av[1] = "127.0.0.1";
                    579:        av[2] = conn_str;
                    580:        av[3] = control_port_str;
                    581:        av[4] = server_port_str;
                    582:        av[5] = server;
                    583:        av[6] = use_x ? "1" : "0";
                    584:        av[7] = 0;
                    585:
                    586:        _spawnv(_P_NOWAIT,AsirExe,av);
                    587: //     _spawnv(_P_NOWAIT,"d:\\home\\noro\\engine2000\\debug\\engine.exe",av);
                    588: //     printf("ox_launch 127.0.0.1 %s %s %s %s 0\n",conn_str,control_port_str,server_port_str,server);
                    589: #else
1.28      noro      590:        if ( use_unix || !host ) {
1.27      noro      591: #if defined(__CYGWIN__)
1.29    ! noro      592:                get_launcher_path(win_launcher);
        !           593:                if ( dname && get_start_path(win_start) ) {
        !           594:                        sprintf(cmd,"%s %s %s %s %s %s %s 1",
        !           595:                                win_start,win_launcher,use_unix?".":"127.1",conn_str,
        !           596:                                control_port_str,server_port_str,server);
        !           597:                        system(cmd);
        !           598:                } else {
        !           599:                        if ( !fork() ) {
        !           600:                                setpgid(0,getpid());
        !           601:                                execlp(launcher,launcher,use_unix?".":"127.1",conn_str,
        !           602:                                        control_port_str,server_port_str,server,dname0,"-nolog",0);
1.27      noro      603:                        }
1.29    ! noro      604:                }
1.27      noro      605: #else
1.29    ! noro      606:                if ( !fork() ) {
        !           607:                        setpgid(0,getpid());
1.28      noro      608:                        if ( dname )
1.13      noro      609:                                execlp("xterm","xterm","-name",OX_XTERM,"-T","ox_launch:local","-display",dname,
1.28      noro      610:                                        "-geometry","60x10","-e",launcher,use_unix?".":"127.1",conn_str,
1.1       noro      611:                                        control_port_str,server_port_str,server,dname,0);
1.27      noro      612:                        else
1.28      noro      613:                                execlp(launcher,launcher,use_unix?".":"127.1",conn_str,
1.17      noro      614:                                        control_port_str,server_port_str,server,dname0,"-nolog",0);
1.1       noro      615:                }
1.29    ! noro      616: #endif
1.1       noro      617:        } else if ( conn_to_serv == 2 ) {
                    618:                /* special support for java */
                    619:                if ( dname )
                    620:                        sprintf(cmd,
1.13      noro      621:                                "%s -n %s \"(cd %s; xterm -name %s %s -geometry 60x10 -e java %s -host %s -control %s -data %s)>&/dev/null&\">/dev/null",
1.1       noro      622:                                rsh,host,launcher,OX_XTERM,dname,server,localhost,control_port_str,server_port_str);
                    623:                else
                    624:                        sprintf(cmd,
                    625:                                "%s -n %s \"(cd %s; java %s -host %s -control %s -data %s)>&/dev/null&\">/dev/null",
                    626:                                rsh,host,launcher,server,localhost,
                    627:                                control_port_str,server_port_str,server);
                    628:                fprintf(stderr,"%s\n",cmd);
                    629:                sleep(20);
                    630: /*             system(cmd); */
1.15      noro      631:        } else {
1.1       noro      632:                if ( dname )
1.13      noro      633:                        if ( use_ssh )
1.25      noro      634:                                sprintf(cmd,
1.14      noro      635: "%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",
1.13      noro      636:                                rsh,host,OX_XTERM,host,launcher,localhost,conn_str,
                    637:                                control_port_str,server_port_str,server,"1");
                    638:                        else
1.25      noro      639:                                sprintf(cmd,
1.14      noro      640: "%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",
1.13      noro      641:                                rsh,host,OX_XTERM,host,dname,launcher,localhost,conn_str,
1.1       noro      642:                                control_port_str,server_port_str,server,dname);
                    643:                else
1.25      noro      644:                        if ( use_ssh )
                    645:                                sprintf(cmd,
                    646: "%s -f -n %s \"%s %s %s %s %s %s %s %s>&/dev/null&\">/dev/null",
                    647:                                rsh,host,launcher,localhost,conn_str,
                    648:                                control_port_str,server_port_str,server,"1","-nolog");
                    649:                        else
                    650:                                sprintf(cmd,
1.17      noro      651: "%s -n %s \"%s %s %s %s %s %s %s %s>&/dev/null&\">/dev/null",
1.1       noro      652:                                rsh,host,launcher,localhost,conn_str,
1.17      noro      653:                                control_port_str,server_port_str,server,dname0,"-nolog");
1.1       noro      654:                system(cmd);
                    655:        }
1.15      noro      656: #endif /* VISUAL */
1.1       noro      657: }
                    658:
1.26      noro      659: void Pox_launch(NODE arg,Obj *rp)
1.1       noro      660: {
1.26      noro      661:        ox_launch_main(1,arg,rp);
1.1       noro      662: }
                    663:
1.26      noro      664: void Pox_launch_nox(NODE arg,Obj *rp)
1.1       noro      665: {
1.26      noro      666:        ox_launch_main(0,arg,rp);
1.1       noro      667: }
                    668:
                    669: /*
                    670:        ox_launch() : invoke local ox_asir
                    671:        ox_launch(0,ox_xxx) : invoke local ox_xxx with asir_libdir/ox_launch
                    672:        ox_launch(remote,lib,ox_xxx) : invoke remote ox_xxx with lib/ox_launch
                    673: */
                    674:
1.26      noro      675: void ox_launch_main(int with_x,NODE arg,Obj *p)
1.1       noro      676: {
                    677:        char *str;
1.26      noro      678:        char *hostname,*servername;
1.1       noro      679:        char *control;
                    680:        int use_unix;
1.26      noro      681:        Q ret;
1.1       noro      682:        extern char *asir_libdir;
                    683:
                    684:        if ( arg && ARG0(arg) && argc(arg) != 3 )
                    685:                error("ox_launch : argument mismatch");
                    686:        control = (char *)MALLOC(BUFSIZ);
                    687:        if ( !arg || ( !ARG0(arg) && argc(arg) == 1 ) ) {
                    688:                sprintf(control,"%s/ox_launch",asir_libdir);
1.28      noro      689:                use_unix = IS_CYGWIN ? 0 : 1;
1.1       noro      690:                servername = (char *)MALLOC(BUFSIZ);
                    691:                sprintf(servername,"%s/ox_asir",asir_libdir);
                    692:        } else if ( !ARG0(arg) && argc(arg) == 2 ) {
                    693:                sprintf(control,"%s/ox_launch",asir_libdir);
1.28      noro      694:                use_unix = IS_CYGWIN ? 0 : 1;
1.1       noro      695:                str = BDY((STRING)ARG1(arg));
                    696:                if ( str[0] == '/' )
                    697:                        servername = str;
                    698:                else {
                    699:                        servername = (char *)MALLOC(BUFSIZ);
                    700:                        sprintf(servername,"%s/%s",asir_libdir,str);
                    701:                }
                    702:        } else {
                    703:                sprintf(control,"%s/ox_launch",BDY((STRING)ARG1(arg)));
                    704:                if ( !ARG0(arg) )
1.28      noro      705:                        use_unix = IS_CYGWIN ? 0 : 1;
1.1       noro      706:                else
                    707:                        use_unix = 0;
                    708:                str = BDY((STRING)ARG2(arg));
                    709:                if ( str[0] == '/' )
                    710:                        servername = str;
                    711:                else {
                    712:                        servername = (char *)MALLOC(BUFSIZ);
                    713:                        sprintf(servername,"%s/%s",BDY((STRING)ARG1(arg)),str);
                    714:                }
                    715:        }
                    716:        if ( arg && ARG0(arg) )
                    717:                hostname = BDY((STRING)ARG0(arg));
                    718:        else
                    719:                hostname = 0;
1.26      noro      720:        ox_launch_generic(hostname,control,servername,use_unix,0,with_x,0,&ret);
                    721:        *p = (Obj)ret;
1.1       noro      722: }
                    723:
1.26      noro      724: int register_server(int af_unix,int m,int c)
1.1       noro      725: {
1.26      noro      726:        int s,i;
1.1       noro      727:        struct m_c *t;
1.9       noro      728: #define INIT_TAB_SIZ 64
1.1       noro      729:
                    730:        if ( c < 0 )
                    731:                return -1;
                    732:        if ( !m_c_tab ) {
1.9       noro      733:                s = INIT_TAB_SIZ*sizeof(struct m_c);
1.8       noro      734:                m_c_tab = (struct m_c *)MALLOC_ATOMIC(s);
1.9       noro      735:                for ( i = 0; i < INIT_TAB_SIZ; i++ ) {
1.8       noro      736:                        m_c_tab[i].af_unix = 0;
                    737:                        m_c_tab[i].m = m_c_tab[i].c = -1;
                    738:                }
1.9       noro      739:                m_c_s = INIT_TAB_SIZ;
1.1       noro      740:        }
                    741: #if !MPI
                    742:        for ( i = 0; i < m_c_i; i++ )
1.8       noro      743:                if ( (m_c_tab[i].m<0) && (m_c_tab[i].c<0) )
1.1       noro      744:                        break;
                    745:        if ( i < m_c_i ) {
                    746:                m_c_tab[i].m = m; m_c_tab[i].c = c;
                    747:                m_c_tab[i].af_unix = af_unix;
                    748:                return i;
                    749:        }
                    750: #endif
                    751:        if ( m_c_i == m_c_s ) {
1.9       noro      752:                s = (m_c_s+INIT_TAB_SIZ)*sizeof(struct m_c);
1.27      noro      753:                t = (struct m_c *)MALLOC_ATOMIC(s); bzero((void *)m_c_tab,s);
                    754:                bcopy((void *)m_c_tab,(void *)t,m_c_s*sizeof(struct m_c));
1.9       noro      755:                for ( i = 0; i < INIT_TAB_SIZ; i++ ) {
1.8       noro      756:                        m_c_tab[m_c_s+i].af_unix = 0;
                    757:                        m_c_tab[m_c_s+i].m = m_c_tab[m_c_s+i].c = -1;
                    758:                }
1.9       noro      759:                m_c_s += INIT_TAB_SIZ; m_c_tab = t;
1.1       noro      760:        }
                    761:        m_c_tab[m_c_i].m = m; m_c_tab[m_c_i].c = c;
                    762:        m_c_tab[m_c_i].af_unix = af_unix;
                    763:        return m_c_i++;
                    764: }
                    765:
                    766: /* iofp index => m_c_tab index */
                    767:
1.26      noro      768: int get_mcindex(int i)
1.1       noro      769: {
                    770:        int j;
                    771:
                    772:        for ( j = 0; j < m_c_i; j++ )
                    773:                if ( m_c_tab[j].c == i )
                    774:                        return j;
                    775:        return -1;
                    776: }
                    777:
                    778: /* arg = [ind0,ind1,...]; indk = index to m_c_tab */
                    779:
1.26      noro      780: void Pox_select(NODE arg,LIST *rp)
1.1       noro      781: {
                    782:        int fd,n,i,index,mcind;
                    783:        fd_set r,w,e;
                    784:        NODE list,t,t1;
                    785:        Q q;
                    786:        double max;
                    787:        struct timeval interval;
                    788:        struct timeval *tvp;
                    789:
                    790:        list = BDY((LIST)ARG0(arg)); arg = NEXT(arg);
                    791:        if ( arg ) {
                    792:                max = ToReal((Num)BDY(arg));
                    793:                interval.tv_sec = (int)max;
                    794:                interval.tv_usec = (int)((max-(int)max)*1000000);
                    795:                tvp = &interval;
                    796:        } else
                    797:                tvp = 0;
                    798:
                    799:        FD_ZERO(&r); FD_ZERO(&w); FD_ZERO(&e);
                    800:        for ( t = list; t; t = NEXT(t) ) {
                    801:                index = QTOS((Q)BDY(t));
                    802:                valid_mctab_index(index);
1.26      noro      803:                fd = get_fd(m_c_tab[index].c); FD_SET((unsigned int)fd,&r);
1.1       noro      804:        }
                    805:        n = select(FD_SETSIZE,&r,&w,&e,tvp);
                    806:        for ( i = 0, t = 0; n && i < FD_SETSIZE; i++ )
                    807:                if ( FD_ISSET(i,&r) ) {
                    808:                        /* index : index to iofp array */
                    809:                        index = get_index(i);
                    810:                        /* mcind : index to m_c_tab array */
                    811:                        mcind = get_mcindex(index);
                    812:                        n--; STOQ(mcind,q); MKNODE(t1,q,t); t = t1;
                    813:                }
                    814:        MKLIST(*rp,t);
                    815: }
                    816:
1.26      noro      817: void Pox_flush(NODE arg,Q *rp)
1.1       noro      818: {
                    819:        int index = QTOS((Q)ARG0(arg));
                    820:
                    821:        valid_mctab_index(index);
                    822:        ox_flush_stream_force(m_c_tab[index].c);
                    823:        *rp = ONE;
                    824: }
                    825:
1.26      noro      826: void Pox_send_raw_cmo(NODE arg,Obj *rp)
1.8       noro      827: {
                    828:        int s;
                    829:        int index = QTOS((Q)ARG0(arg));
                    830:
                    831:        valid_mctab_index(index);
                    832:        s = m_c_tab[index].c;
                    833:        ox_write_cmo(s,(Obj)ARG1(arg));
                    834:        /* flush always */
                    835:        ox_flush_stream(s);
                    836:        *rp = 0;
                    837: }
                    838:
1.26      noro      839: void Pox_recv_raw_cmo(NODE arg,Obj *rp)
1.8       noro      840: {
                    841:        int s;
                    842:        int index = QTOS((Q)ARG0(arg));
                    843:
                    844:        valid_mctab_index(index);
                    845:        s = m_c_tab[index].c;
                    846:        ox_read_cmo(s,rp);
                    847: }
                    848:
1.26      noro      849: void Pox_push_local(NODE arg,Obj *rp)
1.1       noro      850: {
                    851:        int s;
                    852:        struct oLIST dummy;
                    853:        VL vl;
                    854:        int index = QTOS((Q)ARG0(arg));
                    855:
                    856:        valid_mctab_index(index);
                    857:        s = m_c_tab[index].c; arg = NEXT(arg);
                    858:
                    859:        dummy.id = O_LIST; dummy.body = arg;
                    860:        get_vars_recursive((Obj)&dummy,&vl);
                    861:
                    862:        ox_send_local_ring(s,vl);
                    863:        for ( ; arg; arg = NEXT(arg) )
                    864:                ox_send_local_data(s,BDY(arg));
                    865:        *rp = 0;
                    866: }
                    867:
1.26      noro      868: void Pox_push_cmo(NODE arg,Obj *rp)
1.1       noro      869: {
                    870:        int s;
                    871:        int index = QTOS((Q)ARG0(arg));
                    872:
                    873:        valid_mctab_index(index);
                    874:        s = m_c_tab[index].c; arg = NEXT(arg);
                    875:        for ( ; arg; arg = NEXT(arg) )
                    876:                ox_send_data(s,BDY(arg));
                    877:        *rp = 0;
                    878: }
                    879:
1.26      noro      880: void Pox_push_vl(NODE arg,Obj *rp)
1.1       noro      881: {
                    882:        int index = QTOS((Q)ARG0(arg));
                    883:
                    884:        valid_mctab_index(index);
                    885:        ox_send_local_ring(m_c_tab[index].c,CO);
                    886:        *rp = 0;
                    887: }
                    888:
1.26      noro      889: void Pox_pop_local(NODE arg,Obj *rp)
1.1       noro      890: {
                    891:        int s;
                    892:        int index = QTOS((Q)ARG0(arg));
                    893:
                    894:        valid_mctab_index(index);
                    895:        s = m_c_tab[index].c;
                    896:        ox_send_cmd(s,SM_popSerializedLocalObject);
                    897:        ox_flush_stream_force(s);
                    898:        ox_get_result(s,rp);
                    899: }
                    900:
1.26      noro      901: void Pox_pop_cmo(NODE arg,Obj *rp)
1.1       noro      902: {
                    903:        int s;
                    904:        int index = QTOS((Q)ARG0(arg));
                    905:
                    906:        valid_mctab_index(index);
                    907:        s = m_c_tab[index].c;
                    908:        ox_send_cmd(s,SM_popCMO);
                    909:        ox_flush_stream_force(s);
                    910:        ox_get_result(s,rp);
                    911: }
                    912:
1.26      noro      913: void Pox_pop0_local(NODE arg,Obj *rp)
1.1       noro      914: {
                    915:        int index = QTOS((Q)ARG0(arg));
                    916:
                    917:        valid_mctab_index(index);
                    918:        ox_send_cmd(m_c_tab[index].c,SM_popSerializedLocalObject);
                    919:        *rp = 0;
                    920: }
                    921:
1.26      noro      922: void Pox_pop0_cmo(NODE arg,Obj *rp)
1.1       noro      923: {
                    924:        int index = QTOS((Q)ARG0(arg));
                    925:
                    926:        valid_mctab_index(index);
                    927:        ox_send_cmd(m_c_tab[index].c,SM_popCMO);
                    928:        *rp = 0;
                    929: }
                    930:
1.26      noro      931: void Pox_pop0_string(NODE arg,STRING *rp)
1.1       noro      932: {
                    933:        int index = QTOS((Q)ARG0(arg));
                    934:
                    935:        valid_mctab_index(index);
                    936:        ox_send_cmd(m_c_tab[index].c,SM_popString);
                    937:        *rp = 0;
                    938: }
                    939:
1.26      noro      940: void Pox_pop_string(NODE arg,Obj *rp)
1.1       noro      941: {
1.26      noro      942:        int s;
1.1       noro      943:        int index = QTOS((Q)ARG0(arg));
                    944:
                    945:        valid_mctab_index(index);
                    946:        s = m_c_tab[index].c;
                    947:        ox_send_cmd(s,SM_popString);
                    948:        ox_flush_stream_force(s);
                    949:        ox_get_result(s,rp);
                    950: }
                    951:
1.26      noro      952: void Pox_get(NODE arg,Obj *rp)
1.1       noro      953: {
1.3       noro      954:        int index;
1.1       noro      955:        int s;
                    956:
1.3       noro      957:        if ( !arg ) {
                    958:                /* client->server */
                    959:                ox_get_result(0,rp);
                    960:        } else {
                    961:                /* server->client */
                    962:                index = QTOS((Q)ARG0(arg));
                    963:                valid_mctab_index(index);
                    964:                s = m_c_tab[index].c;
                    965:                ox_flush_stream_force(s);
                    966:                ox_get_result(s,rp);
                    967:        }
1.1       noro      968: }
                    969:
1.26      noro      970: void Pox_pops(NODE arg,Obj *rp)
1.1       noro      971: {
                    972:        int s;
                    973:        USINT n;
                    974:        int index = QTOS((Q)ARG0(arg));
                    975:
                    976:        valid_mctab_index(index);
                    977:        s = m_c_tab[index].c;
                    978:        if ( NEXT(arg) )
                    979:                MKUSINT(n,QTOS((Q)ARG1(arg)));
                    980:        else
                    981:                MKUSINT(n,1);
                    982:        ox_send_data(s,n);
                    983:        ox_send_cmd(s,SM_pops);
                    984:        *rp = 0;
                    985: }
                    986:
1.26      noro      987: void Pox_execute_function(NODE arg,Obj *rp)
1.1       noro      988: {
                    989:        int s;
                    990:        USINT ui;
                    991:        int index = QTOS((Q)ARG0(arg));
                    992:
                    993:        valid_mctab_index(index);
                    994:        s = m_c_tab[index].c;
                    995:        MKUSINT(ui,QTOS((Q)ARG2(arg)));
                    996:        ox_send_data(s,ui);
                    997:        ox_send_data(s,ARG1(arg));
                    998:        ox_send_cmd(s,SM_executeFunction);
                    999:        *rp = 0;
                   1000: }
                   1001:
1.26      noro     1002: void Pox_setname(NODE arg,Obj *rp)
1.1       noro     1003: {
                   1004:        int s;
                   1005:        int index = QTOS((Q)ARG0(arg));
                   1006:
                   1007:        valid_mctab_index(index);
                   1008:        s = m_c_tab[index].c;
                   1009:        ox_send_data(s,ARG1(arg));
                   1010:        ox_send_cmd(s,SM_setName);
                   1011:        *rp = 0;
                   1012: }
                   1013:
1.26      noro     1014: void Pox_evalname(NODE arg,Obj *rp)
1.1       noro     1015: {
                   1016:        int s;
                   1017:        int index = QTOS((Q)ARG0(arg));
                   1018:
                   1019:        valid_mctab_index(index);
                   1020:        s = m_c_tab[index].c;
                   1021:        ox_send_data(s,ARG1(arg));
                   1022:        ox_send_cmd(s,SM_evalName);
                   1023:        *rp = 0;
                   1024: }
                   1025:
1.26      noro     1026: void Pox_execute_string(NODE arg,Obj *rp)
1.1       noro     1027: {
                   1028:        int s;
                   1029:        int index = QTOS((Q)ARG0(arg));
                   1030:
                   1031:        valid_mctab_index(index);
                   1032:        s = m_c_tab[index].c;
                   1033:        ox_send_data(s,ARG1(arg));
                   1034:        ox_send_cmd(s,SM_executeStringByLocalParser);
                   1035:        *rp = 0;
                   1036: }
                   1037:
                   1038: /* arg=[sid,fname,arg0,arg1,...,arg{n-1}] */
                   1039:
1.26      noro     1040: void Pox_rpc(NODE arg,Obj *rp)
1.1       noro     1041: {
                   1042:        int s,i,n;
                   1043:        STRING f;
                   1044:        USINT ui;
                   1045:        pointer *w;
                   1046:        NODE t;
                   1047:        int index = QTOS((Q)ARG0(arg));
                   1048:
                   1049:        valid_mctab_index(index);
                   1050:        s = m_c_tab[index].c; arg = NEXT(arg);
                   1051:        f = (STRING)BDY(arg); arg = NEXT(arg);
                   1052:        ox_send_local_ring(s,CO);
                   1053:        for ( n = 0, t = arg; t; t = NEXT(t), n++ );
                   1054:        w = (pointer *)ALLOCA(n*sizeof(pointer));
                   1055:        for ( i = 0, t = arg; i < n; t = NEXT(t), i++ )
                   1056:                w[i] = BDY(t);
                   1057:        for ( i = n-1; i >= 0; i-- )
                   1058:                ox_send_local_data(s,w[i]);
                   1059:        MKUSINT(ui,n);
                   1060:        ox_send_data(s,ui);
                   1061:        ox_send_data(s,f);
                   1062:        ox_send_cmd(s,SM_executeFunction);
                   1063:        *rp = 0;
                   1064: }
                   1065:
1.26      noro     1066: void Pox_cmo_rpc(NODE arg,Obj *rp)
1.1       noro     1067: {
                   1068:        int s,i,n;
                   1069:        STRING f;
                   1070:        USINT ui;
                   1071:        NODE t;
                   1072:        pointer *w;
                   1073:        int index = QTOS((Q)ARG0(arg));
                   1074:
                   1075:        valid_mctab_index(index);
                   1076:        s = m_c_tab[index].c; arg = NEXT(arg);
                   1077:        f = (STRING)BDY(arg); arg = NEXT(arg);
                   1078:        for ( n = 0, t = arg; t; t = NEXT(t), n++ );
                   1079:        w = (pointer *)ALLOCA(n*sizeof(pointer));
                   1080:        for ( i = 0, t = arg; i < n; t = NEXT(t), i++ )
                   1081:                w[i] = BDY(t);
                   1082:        for ( i = n-1; i >= 0; i-- )
                   1083:                ox_send_data(s,w[i]);
                   1084:        MKUSINT(ui,n);
                   1085:        ox_send_data(s,ui);
                   1086:        ox_send_data(s,f);
                   1087:        ox_send_cmd(s,SM_executeFunction);
                   1088:        *rp = 0;
                   1089: }
                   1090:
1.26      noro     1091: void Pox_reset(NODE arg,Q *rp)
1.1       noro     1092: {
                   1093:        USINT t;
1.26      noro     1094:        int id,c,m;
1.1       noro     1095:        Obj obj;
                   1096:        int index = QTOS((Q)ARG0(arg));
                   1097:
                   1098:        valid_mctab_index(index);
                   1099:        m = m_c_tab[index].m;
                   1100:        c = m_c_tab[index].c;
                   1101:        if ( m >= 0 ) {
                   1102:                if ( argc(arg) == 1 ) {
                   1103:                        ox_send_cmd(m,SM_control_reset_connection);
                   1104:                        ox_flush_stream_force(m);
1.26      noro     1105:                        ox_recv(m,&id,&obj); t = (USINT)obj;
1.1       noro     1106:                }
                   1107:                *rp = ONE;
                   1108: #if defined(VISUAL)
                   1109:                Sleep(100);
                   1110:                ox_send_cmd(c,SM_nop);
                   1111:                ox_flush_stream_force(c);
                   1112: #endif
                   1113:                while ( 1 ) {
                   1114:                        ox_recv(c,&id,&obj);
                   1115:                        if ( id == OX_SYNC_BALL )
                   1116:                                break;
                   1117:                }
                   1118:                ox_send_sync(c);
1.5       noro     1119:        } else
                   1120:                *rp = 0;
                   1121: }
                   1122:
1.26      noro     1123: void Pox_intr(NODE arg,Q *rp)
1.5       noro     1124: {
                   1125:        int m;
                   1126:        int index = QTOS((Q)ARG0(arg));
                   1127:
                   1128:        valid_mctab_index(index);
                   1129:        m = m_c_tab[index].m;
                   1130:        if ( m >= 0 ) {
                   1131:                if ( argc(arg) == 1 ) {
                   1132:                        ox_send_cmd(m,SM_control_intr);
                   1133:                        ox_flush_stream_force(m);
                   1134:                }
                   1135:                *rp = ONE;
1.1       noro     1136:        } else
                   1137:                *rp = 0;
                   1138: }
                   1139:
1.26      noro     1140: void Pox_sync(NODE arg,Q *rp)
1.1       noro     1141: {
                   1142:        int c;
                   1143:        int index = QTOS((Q)ARG0(arg));
                   1144:
                   1145:        valid_mctab_index(index);
                   1146:        c = m_c_tab[index].c;
                   1147:        ox_send_sync(c);
                   1148:        *rp = 0;
                   1149: }
                   1150:
1.26      noro     1151: void Pox_shutdown(NODE arg,Q *rp)
1.1       noro     1152: {
                   1153:        int s;
                   1154:        int index = QTOS((Q)ARG0(arg));
1.26      noro     1155: #if !defined(VISUAL)
1.1       noro     1156:        int status;
1.26      noro     1157: #endif
1.1       noro     1158:
                   1159:        valid_mctab_index(index);
                   1160:        s = m_c_tab[index].m;
                   1161:        ox_send_cmd(s,SM_shutdown);
                   1162:        free_iofp(s);
1.18      noro     1163: #if !defined(VISUAL)
                   1164:        s = m_c_tab[index].c;
                   1165:        free_iofp(s);
                   1166: #endif
1.1       noro     1167: #if !MPI && !defined(VISUAL)
                   1168:        if ( m_c_tab[index].af_unix )
                   1169:                wait(&status);
                   1170: #endif
1.8       noro     1171:        m_c_tab[index].m = -1; m_c_tab[index].c = -1;
1.1       noro     1172:        m_c_tab[index].af_unix = 0;
                   1173:        *rp = 0;
                   1174: }
                   1175:
1.26      noro     1176: void Pox_push_cmd(NODE arg,Q *rp)
1.1       noro     1177: {
1.7       noro     1178:        int ui;
1.1       noro     1179:        int index = QTOS((Q)ARG0(arg));
                   1180:
                   1181:        valid_mctab_index(index);
1.7       noro     1182:        ui = QTOS((Q)ARG1(arg));
1.1       noro     1183:        ox_send_cmd(m_c_tab[index].c,ui);
                   1184:        *rp = 0;
                   1185: }
1.16      noro     1186:
                   1187: void shutdown_all() {
                   1188:        int s;
                   1189:        int i,index;
1.26      noro     1190: #if !defined(VISUAL)
1.16      noro     1191:        int status;
1.26      noro     1192: #endif
1.16      noro     1193:
                   1194:        for ( i = I_am_server?1:0; i < m_c_i; i++ ) {
                   1195:                index = i;
                   1196:                check_valid_mctab_index(index);
                   1197:                if ( index < 0 )
                   1198:                        continue;
                   1199:                s = m_c_tab[index].m;
                   1200:                ox_send_cmd(s,SM_shutdown);
1.21      noro     1201: #if defined(VISUAL)
                   1202:        Sleep(1000);
                   1203: #endif
1.16      noro     1204:                free_iofp(s);
1.18      noro     1205: #if !defined(VISUAL)
                   1206:                s = m_c_tab[index].c;
                   1207:                free_iofp(s);
                   1208: #endif
1.16      noro     1209: #if !MPI && !defined(VISUAL)
                   1210:                if ( m_c_tab[index].af_unix )
                   1211:                        wait(&status);
                   1212: #endif
                   1213:                m_c_tab[index].m = 0; m_c_tab[index].c = 0;
                   1214:                m_c_tab[index].af_unix = 0;
                   1215:        }
                   1216: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>