Patrick
/
Nife_v0
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Nife version Beta
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
11 Commits
1 Branch
631 KiB
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
Nife_v0/src/net.c

1074 lines
24 KiB
Raw Permalink Blame History 

  1. /* Copyright (C) 2011-2022  Patrick H. E. Foubet - S.E.R.I.A.N.E.

  2. 

  3. This program is free software: you can redistribute it and/or modify

  4. it under the terms of the GNU General Public License as published by

  5. the Free Software Foundation, either version 3 of the License, or any

  6. later version.

  7. 

  8. This program is distributed in the hope that it will be useful,

  9. but WITHOUT ANY WARRANTY; without even the implied warranty of

  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  11. GNU General Public License for more details.

  12. 

  13. You should have received a copy of the GNU General Public License

  14. along with this program.  If not, see <http://www.gnu.org/licenses/>

  15. *******************************************************************/

  16. /* net.c */

  17. #include "conf.h"

  18. 

  19. #include <stdio.h>

  20. #include <stdlib.h>

  21. #include <string.h>

  22. #include <strings.h>

  23. #include <sys/types.h>

  24. #include <sys/time.h>

  25. #include <sys/socket.h>

  26. #include <signal.h>

  27. #include <sys/stat.h>

  28. #include <fcntl.h>

  29. #include <unistd.h>

  30. /*

  31. */

  32. #include <netinet/in.h>

  33. #include <arpa/inet.h>

  34. #include <netdb.h>

  35. 

  36. #include "nife.h"

  37. #include "mth.h"

  38. #include "net.h"

  39. #include "lib.h"

  40. #include "debug.h"

  41. #include "stackC.h"

  42. #include "stackN.h"

  43. #include "stackL.h"

  44. #include "foncs.h"

  45. #include "scs.h"

  46. #include "err.h"

  47. 

  48. #define LOCALS "localhost"

  49. #define MAXCLI 200

  50. #define LLIB 24

  51. static char *NetName=NULL;

  52. /* for messages */

  53. struct Mess1 {

  54.     uint32_t pid;

  55.     union {

  56.       char lib[LLIB];

  57.       in_port_t port;

  58.     };

  59. };

  60. 

  61. /* RPC structures */

  62. struct Nrpc {

  63.     uint32_t nkey;  /* netkey */

  64.     char fct[LLIB]; /* function */

  65.     struct Nrpc *next;

  66. };

  67. /* Table for Server */

  68. struct Client {

  69.     uint32_t pid;

  70.     long long dt; /* delta time local - remote */

  71.     struct in_addr ip; /* net order */

  72.     in_port_t  port; /* Nrpc port in net order */

  73.     struct Nrpc *ff; /* first function */

  74.     char lib[LLIB];

  75. } TCli[MAXCLI];

  76. 

  77. static int NCli, STS=0, SameSaS=0;

  78. 

  79. static void initCli(void)

  80. {

  81. int i;

  82.    for(i=0;i<MAXCLI;i++) TCli[i].pid=0;

  83.    NCli=0;

  84. }

  85. 

  86. static int addCli(uint32_t pid, struct in_addr ip, char *lib, long long dt)

  87. {

  88. int i;

  89.    if (NCli==MAXCLI) return -1;

  90.    for(i=0;i<MAXCLI;i++) 

  91.       if (TCli[i].pid == 0) break;

  92.    TCli[i].pid = pid;

  93.    TCli[i].dt = dt;

  94.    TCli[i].port = 0;

  95.    TCli[i].ff = (struct Nrpc*)NULL;

  96.    TCli[i].ip.s_addr = ip.s_addr;

  97.    strncpy(TCli[i].lib,lib,LLIB-1);

  98.    TCli[i].lib[LLIB-1] = '\0';

  99.    NCli++;

  100.    return 0;

  101. }

  102. 

  103. static void delCli(int pid, struct in_addr ip)

  104. {

  105. int i;

  106.    for(i=0;i<MAXCLI;i++) 

  107.       if ((TCli[i].pid == pid) && (TCli[i].ip.s_addr == ip.s_addr)) {

  108.          TCli[i].pid = 0;

  109.          TCli[i].lib[0] = '\0';

  110.          NCli--;

  111.          break;

  112.       }

  113. }

  114. 

  115. static void majNRP(int pid, in_port_t p)

  116. {

  117. int i;

  118.    for(i=0;i<MAXCLI;i++) 

  119.       if (TCli[i].pid == pid) {

  120.          TCli[i].port = p;

  121.          break;

  122.       }

  123. }

  124. 

  125. static long long getDt(int pid, struct in_addr ip)

  126. {

  127. int i;

  128.    for(i=0;i<MAXCLI;i++) 

  129.       if ((TCli[i].pid == pid) && (TCli[i].ip.s_addr == ip.s_addr)) 

  130.          return TCli[i].dt;

  131.    return 0;

  132. }

  133. 

  134. static int getCliId(char *N)

  135. {

  136. int i;

  137.    for(i=0;i<MAXCLI;i++) 

  138.       if (strcmp(TCli[i].lib,N) == 0)

  139.          return i;

  140.    return -1;

  141. }

  142. 

  143. static void listCli(void)

  144. {

  145. int i,j=0;

  146. char S;

  147.    for(i=0;i<MAXCLI;i++) 

  148.       if (TCli[i].pid != 0) {

  149.          j++;

  150.          if (TCli[i].dt == 0) S='=';

  151.          else {

  152.              if (TCli[i].dt > 0) S='+'; else S='-';

  153.          }

  154.          printf("%3d : %6d %15s:%d %c %s\n",j,TCli[i].pid,inet_ntoa(TCli[i].ip),

  155.                   (int)ntohs(TCli[i].port), S, TCli[i].lib);

  156.          /* with dt */

  157. /*

  158.          printf("%3d : %6d %15s %15ld %s\n",j,TCli[i].pid,inet_ntoa(TCli[i].ip),

  159.                   (long)TCli[i].dt, TCli[i].lib);

  160. */

  161.       }

  162. }

  163. 

  164. #define SERV_PORT 32011 /* Stack to Stack Protocol port */

  165. 

  166. /* commands list  (default 1+1) */

  167. #define NET_SLI  '?'	/* ask the stack list */

  168. #define NET_DRS  '-'	/* 1+0 drop net stack */

  169. #define NET_ONR  'a'	/* remote login */

  170. #define NET_ON   'A'	/* login */

  171. #define NET_CAL  'C'	/* calcul of dt */

  172. #define NET_DPH  'd'	/* depth */

  173. #define NET_DAT  'D'	/* data */

  174. #define NET_OFF  'E'	/* logoff */

  175. #define NET_U2S  'F'	/* From user to server */

  176. #define NET_FIL  'f'	/* ok to send file */

  177. #define NET_GDT  'G'	/* get dt */

  178. #define NET_LI   'L'	/* ask the list */

  179. #define NET_NRP  'N'	/* NRpc Port */

  180. #define NET_PAR  'P'	/* call distant parser */

  181. #define NET_RUS  'R'	/* ask to Ressources Usage */

  182. #define NET_STS  'S'	/* ask to Stop The Server */

  183. #define NET_S2U  'T'	/* from server To user */

  184. #define NET_EXE  'X'	/* send a RPC command */

  185. #define NET_ERR  'Z'	/* Error */

  186. #define NET_EOM (char)3 /* End Of Message */

  187. 

  188. #define LNBUF  200

  189. #define LNSRV  24

  190. 

  191. char NetServer[24]=LOCALS;

  192. static int Sock, NET=0;

  193. static struct sockaddr_in Sin, SinSav;

  194. 

  195. static int connSock2(int n) /* connect to Nife RPC Client */

  196. {

  197.    if ((Sock = socket(AF_INET, SOCK_STREAM,  IPPROTO_TCP)) == -1) return 1;

  198.    bcopy(&SinSav,&Sin,sizeof(Sin));

  199.    bcopy(&TCli[n].ip,&Sin.sin_addr,sizeof(Sin.sin_addr));

  200.    bcopy(&TCli[n].port,&Sin.sin_port,sizeof(Sin.sin_port));

  201.    if(connect(Sock,(struct sockaddr *)&Sin,sizeof(Sin)) < 0) return 1;

  202.    return 0; /* OK */

  203. }

  204. 

  205. void IF_Me(void)

  206. {

  207. char * Me;

  208. void * NM;

  209. int i=0;

  210. static char *ve[] = { "NIFENAME", "LOGNAME", "USERNAME", "USER", "" };

  211. static char Nobody[] = "Nobody";

  212.   if (NetName == NULL) {

  213.     Me=NULL;

  214.     while (Me == NULL) {

  215.        if (strlen(ve[i])==0) break;

  216.        Me = getenv(ve[i++]);

  217.     }

  218.     if (Me == NULL) Me=Nobody;

  219.     if ((NM = malloc(strlen(Me)+1)) != NULL)

  220.        strcpy((char*)NM,Me);

  221.     NetName=(char*)NM;

  222.   }

  223.   putString(NetName);

  224. }

  225. 

  226. void IF_NetServer(void)

  227. {

  228. char *s;

  229. int i;

  230.    if (!isNString(1)) {

  231.            messErr(6); return;

  232.    }

  233.    s = getString();

  234.    i=LNSRV-1;

  235.    strncpy(NetServer,s,i);

  236.    NetServer[i]='\0';

  237.    free((void*)s);

  238. }

  239. 

  240. static void stopServ(int TS, char * m, int n)

  241. {

  242. char buf[20];

  243.     perror(m);

  244.     if (TS) sprintf(buf,"main_Serv : Erreur %d %s\n",n,m);

  245.     else    sprintf(buf,"main_Nrpc : Erreur %d %s\n",n,m);

  246.     D_Trace(buf);

  247.     exit(n);

  248. }

  249. 

  250. static char NET_BUF[LNBUF];

  251. 

  252. static int readMess(int s)

  253. {

  254. char * b, *f;

  255.    b = NET_BUF;

  256.    f = b + LNBUF - 1;

  257.    while (1) {

  258.      if (read(s,(void*)b,1) <= 0) break;

  259.      if (*b == NET_EOM) break;

  260.      if (b == f) break;

  261.      b++;

  262.    }

  263.    if (*b != NET_EOM) return -1;

  264.    b++;

  265.    return(b-NET_BUF);

  266. }

  267. 

  268. static int readMess2(int s, int n)

  269. {

  270. char * b, *f;

  271.    b = NET_BUF;

  272.    f = b + n;

  273.    while (1) {

  274.      if (read(s,(void*)b,1) <= 0) break;

  275.      b++;

  276.      if (b == f) break;

  277.    }

  278.    if (*b != NET_EOM) return -1;

  279.    return(n);

  280. }

  281. 

  282. static void readAff(int s, char C)

  283. {

  284. char  b[2];

  285. int ok=0;

  286.    if (read(s,(void*)b,1) <= 0) return;

  287.    if (*b == C) ok=1;

  288.    while (*b != NET_EOM) {

  289.          if (read(s,(void*)b,1) <= 0) break;

  290.          else {

  291.             if (ok) write(1,(void*)b,1);

  292.          }

  293.    }

  294. }

  295. 

  296. static void sendC(char c)

  297. {

  298.     write(Sock,(void*)&c,1);

  299. }

  300. 

  301. static void sendBuf(int s, void * b, size_t no)

  302. {

  303.     write(s,b,no);

  304. }

  305. 

  306. static void rcvBuf(int s, void * b, uint32_t no)

  307. {

  308. int r,ar;

  309. void *t;

  310.     ar = no;

  311.     r = 0;

  312.     t = b;

  313.     while ((r=read(s,t,ar)) != ar) {

  314.         if (r<0) break;

  315.         ar -= r;

  316.         t += r;

  317.     }

  318. }

  319. 

  320. void sendData(int s, void * b, uint32_t n)

  321. {

  322. char c;

  323.     c=NET_DAT;

  324.     write(s,(void*)&c,1);

  325.     n -= lAdrNum(); /* don't send the addresse */

  326.     sendBuf(s,&n,sizeof(n));

  327.     /* sendBuf(s,b,(size_t)n); */

  328.     sendBuf(s,b,sizeof(uint32_t)*2);

  329.     b+=(sizeof(uint32_t)*2)+lAdrNum();

  330.     n-=(sizeof(uint32_t)*2);

  331.     sendBuf(s,b,(size_t)n);

  332. }

  333. 

  334. void sendDataC(void *b, uint32_t n)

  335. {

  336.     sendData(Sock,b,n);

  337. }

  338. 

  339. void sendFile(int s, int fid)

  340. {

  341. int n;

  342. char Buf[LNBUF];

  343.    while ((n = read(fid,(void*)Buf,LNBUF)) > 0)

  344.      sendBuf(s,(void*)Buf,(size_t)n);

  345.    close(fid);

  346. }

  347. 

  348. static void sendInsc(void)

  349. {

  350. char *s;

  351. struct Mess1 M1;

  352. uint32_t scs;

  353. struct timeval tv;

  354. long long v;

  355. 

  356.     scs = getScs();

  357.     s = getString();

  358.     M1.pid = getpid();

  359.     strncpy(M1.lib,s,LLIB-1);

  360.     M1.lib[LLIB-1]='\0';

  361.     if (SameSaS) sendC(NET_ON);

  362.     else sendC(NET_ONR);

  363.     write(Sock,(void*)&scs,sizeof(scs)); 

  364.     write(Sock,(void*)&M1,sizeof(M1)); 

  365.     sendC(NET_EOM);

  366.     /* update NetName */

  367.     if (NetName != NULL) free((void*)NetName);

  368.     NetName=s;

  369.     if (SameSaS==0) {

  370.       if (readMess(Sock) == 2) {

  371.          if (*NET_BUF == (NET_CAL))  {

  372.             gettimeofday(&tv,NULL);

  373.             v=Nife_time(tv);

  374.             sendC(NET_CAL+1);

  375.             write(Sock,(void*)&v,sizeof(v)); 

  376.             sendC(NET_EOM);

  377.          }

  378.       }

  379.     } else SameSaS=0;

  380. }

  381. 

  382. static void sendGetStd(char Code)

  383. {

  384. struct Mess1 M1;

  385.     switch(Code) {

  386.       case NET_OFF :

  387.       case NET_GDT :

  388.          M1.pid = getpid();

  389.          break;

  390.       default :

  391.          M1.pid = NetKey;

  392.     }

  393.     strcpy(M1.lib,"-");

  394.     sendC(Code);

  395.     write(Sock,(void*)&M1,sizeof(M1)); 

  396.     sendC(NET_EOM);

  397. }

  398. 

  399. static void sendNrpcPort(in_port_t P)

  400. {

  401. struct Mess1 M1;

  402.     M1.pid = getppid(); /* parent pid ! */

  403.     M1.port = P;

  404.     sendC(NET_NRP);

  405.     write(Sock,(void*)&M1,sizeof(M1)); 

  406.     sendC(NET_EOM);

  407. }

  408. 

  409. static void send1car(int s, char c)

  410. {

  411. char b[2];

  412.     b[0]=c;

  413.     b[1]=NET_EOM;

  414.     write(s,b,2); 

  415. }

  416. 

  417. void NTraceM1(char * A)

  418. {

  419. struct Mess1 M1;

  420. char buf[50];

  421.    bcopy((void*)(A+1),(void*)&M1,sizeof(M1));

  422.    sprintf(buf,"TraceM1 %c %d %s !",*A, M1.pid, M1.lib);

  423.    D_Trace(buf);

  424. }

  425. 

  426. void NTraceData(char A, long n)

  427. {

  428. char buf[50];

  429.    sprintf(buf,"TraceData %c %ld !",A, n);

  430.    D_Trace(buf);

  431. }

  432. 

  433. static void RemotExecBegin(long long k)

  434. {

  435.    putLong(k);

  436.    IF_NetKey();

  437.    IF_netS2U();

  438.    IF_netDropS();

  439. }

  440. 

  441. static void RemotExecEnd(void)

  442. {

  443.    if (noErr()) {

  444.       razErr();

  445.       IF_stack_clear(); /* clear all stacks */

  446.       IF_stackL_clear();

  447.       IF_stackC_clear();

  448.       IF_NetErrVal();

  449.    }

  450.    IF_depth();

  451.    IF_netU2S();

  452.    IF_stack_clear(); /* don't eat any bread ! */

  453.    IF_stackL_clear();

  454.    IF_stackC_clear();

  455. }

  456. 

  457. static void net_servrpc(int s)

  458. {

  459. int i, j, fid;

  460. uint32_t k;

  461. char *sF, nF[30];

  462.    i=readMess(s);

  463.    NET_BUF[i]='\0';

  464.    D_TraceH(NET_BUF,i); /* to debug */

  465.    switch(*NET_BUF) {

  466.      case NET_OFF :

  467.        send1car(s, NET_OFF+1);

  468.        D_Close();

  469.        exit(0); /* stop the Nrpc client */

  470.        break;

  471.      case NET_EXE :

  472.        bcopy((void*)(NET_BUF+1),(void*)&k,sizeof(k));

  473.        sF = (char *)(NET_BUF+sizeof(k)+1);

  474.        /* execute the function call */

  475.        /* fprintf(stderr,"Nife_RPC : %s NetKey=%x !\n",sF,k);*/

  476.        RemotExecBegin((long long)k);

  477.        if (!execLibNrpc(sF)) IF_NetErrVal();

  478.        RemotExecEnd();

  479.        break;

  480.      case NET_PAR :

  481.        bcopy((void*)(NET_BUF+1),(void*)&k,sizeof(k));

  482.        sprintf(nF,"w_%d.nif",getpid());

  483.        if ((fid = open(nF,O_CREAT|O_TRUNC|O_RDWR,0600)) != -1) {

  484.           j=1;

  485.           while ((j==1) && ((i=read(s,NET_BUF,LNBUF)) > 0)) {

  486.                if (NET_BUF[i-1] == NET_EOM){

  487.                  j=0; i--;

  488.                }

  489.                write(fid, NET_BUF, i);

  490.           }

  491.           close(fid);

  492.           RemotExecBegin((long long)k);

  493.           compileFile(nF);

  494.           RemotExecEnd();

  495.           unlink(nF);

  496.        }

  497.        break;

  498.      default :

  499.        break;

  500.    }

  501. }

  502. 

  503. 

  504. static void net_service(int s)

  505. {

  506. int i, CalDT=0;

  507. uint32_t n, k,scs;

  508. void *M;

  509. struct Mess1 M1;

  510. struct timeval tv;

  511. long long v1, v2, vm, vr, dt;

  512. char c, *sN, *sF;

  513. 

  514.    i=readMess(s);

  515.    NET_BUF[i]='\0';

  516.    D_TraceH(NET_BUF,i); /* for debug */

  517.    switch(*NET_BUF) {

  518.      case NET_ONR :

  519.        CalDT=1;

  520.      case NET_ON :

  521.        /* NTraceM1(NET_BUF); */

  522.        bcopy((void*)(NET_BUF+1),(void*)&k,sizeof(k));

  523.        scs = getScs();

  524.        if (k==scs) {

  525.           bcopy((void*)(NET_BUF+sizeof(k)+1),(void*)&M1,sizeof(M1));

  526.           if (CalDT) {

  527.              gettimeofday(&tv,NULL);

  528.              send1car(s, NET_CAL);

  529.              v1=Nife_time(tv);

  530.              i=readMess(s);

  531.              gettimeofday(&tv,NULL);

  532.              v2=Nife_time(tv);

  533.              if (*NET_BUF == NET_CAL+1) {

  534.                 bcopy((void*)(NET_BUF+1),(void*)&vr,sizeof(vr));

  535.                 vm = v1 + ((v2-v1)/2);

  536.                 addCli(M1.pid, Sin.sin_addr, M1.lib, (int)(vm-vr));

  537.              }

  538.              else

  539.                 addCli(M1.pid, Sin.sin_addr, M1.lib, -9);

  540.              send1car(s, NET_ON+1);

  541.           } else {

  542.              addCli(M1.pid, Sin.sin_addr, M1.lib, 0);

  543.              send1car(s, NET_ON+1);

  544.           }

  545.        }

  546.        else 

  547.           send1car(s, NET_OFF);

  548.        break;

  549.      case NET_OFF :

  550.        bcopy((void*)(NET_BUF+1),(void*)&M1,sizeof(M1));

  551.        delCli(M1.pid, Sin.sin_addr);

  552.        send1car(s, NET_OFF+1);

  553.        if (STS) {

  554.           if (NCli == 0) {

  555.              D_Close();

  556.              exit(0); /* stop the server */

  557.           }

  558.           STS=0;

  559.        }

  560.        break;

  561.      case NET_NRP :

  562.        bcopy((void*)(NET_BUF+1),(void*)&M1,sizeof(M1));

  563.        majNRP(M1.pid, M1.port);

  564.        send1car(s, NET_NRP+1);

  565.        break;

  566.      case NET_DPH :

  567.        bcopy((void*)(NET_BUF+1),(void*)&M1,sizeof(M1));

  568.        dt=NetDepth(M1.pid);

  569.        c=*NET_BUF+1;

  570.        write(s,(void*)&c,1);

  571.        write(s,(void*)&dt,sizeof(dt));

  572.        c=NET_EOM;

  573.        write(s,(void*)&c,1);

  574.        break;

  575.      case NET_GDT :

  576.        bcopy((void*)(NET_BUF+1),(void*)&M1,sizeof(M1));

  577.        dt=getDt(M1.pid, Sin.sin_addr);

  578.        c=*NET_BUF+1;

  579.        write(s,(void*)&c,1);

  580.        write(s,(void*)&dt,sizeof(dt));

  581.        c=NET_EOM;

  582.        write(s,(void*)&c,1);

  583.        break;

  584.      case NET_EXE :

  585.        bcopy((void*)(NET_BUF+1),(void*)&k,sizeof(k));

  586.        sN = (char *)(NET_BUF+sizeof(k)+1);

  587.        sF = sN+strlen(sN)+1;

  588.        if (strlen(sN)>=LLIB) sN[LLIB-1]='\0';

  589.        i=getCliId(sN);

  590.        if (i>=0) {

  591.           send1car(s, NET_EXE+1);

  592.           /* send the call */

  593.           if (!connSock2(i)) {

  594.              sendC(NET_EXE);

  595.              sendBuf(Sock,(void*)&k, sizeof(k));

  596.              sendBuf(Sock,(void*)sF, strlen(sF)+1);

  597.              sendC(NET_EOM);

  598.           }

  599.        }

  600.        else send1car(s, NET_ERR);

  601.        break;

  602.      case NET_PAR :

  603.        bcopy((void*)(NET_BUF+1),(void*)&k,sizeof(k));

  604.        sN = (char *)(NET_BUF+sizeof(k)+1);

  605.        if (strlen(sN)>=LLIB) sN[LLIB-1]='\0';

  606.        i=getCliId(sN);

  607.        if (i>=0) {

  608.           /* connect to client */

  609.           if (!connSock2(i)) {

  610.              send1car(s, NET_FIL); /* tell ok to sender */

  611.              sendC(NET_PAR);

  612.              sendBuf(Sock,(void*)&k, sizeof(k));

  613.              sendC(NET_EOM);

  614.              while ((i=read(s,NET_BUF,LNBUF)) > 0) {

  615.                sendBuf(Sock, NET_BUF, i);

  616.                if (NET_BUF[i-1] == NET_EOM) break;

  617.              }

  618.              send1car(s, NET_PAR+1);

  619.           }

  620.           else send1car(s, NET_ERR);

  621.        }

  622.        else send1car(s, NET_ERR);

  623.        break;

  624.      case NET_STS :

  625.        STS=1;

  626.        send1car(s, NET_STS+1);

  627.        break;

  628.      case NET_DRS :

  629.        bcopy((void*)(NET_BUF+1),(void*)&k,sizeof(k));

  630.        IF_netDrop(k);

  631.        break;

  632.      case NET_LI :

  633.        c=*NET_BUF+1;

  634.        write(s,(void*)&c,1);

  635.        dup2(s,1);

  636.        listCli();

  637.        close(1);

  638.        c=NET_EOM;

  639.        write(s,(void*)&c,1);

  640.        break;

  641.      case NET_SLI :

  642.        bcopy((void*)(NET_BUF+1),(void*)&k,sizeof(k));

  643.        c=*NET_BUF+1;

  644.        write(s,(void*)&c,1);

  645.        dup2(s,1);

  646.        IF_show_netStack(k);

  647.        close(1);

  648.        c=NET_EOM;

  649.        write(s,(void*)&c,1);

  650.        break;

  651.      case NET_RUS :

  652.        c=*NET_BUF+1;

  653.        write(s,(void*)&c,1);

  654.        dup2(s,1);

  655.        IF_resUsage();

  656.        close(1);

  657.        c=NET_EOM;

  658.        write(s,(void*)&c,1);

  659.        break;

  660.      case NET_U2S :

  661.        while (1) {

  662.            read(s,(void*)&c,1);

  663.            if (c == NET_EOM) break;

  664.            if (c != NET_DAT) {

  665.               D_Trace("Erreur NET_DAT !"); break;

  666.            }

  667.            read(s,(void*)&n,sizeof(n));

  668.            /* NTraceData(c, n);*/

  669.            /* add the addresse */

  670.            if ((M = malloc((size_t)n+lAdrNum())) != NULL) {

  671.               rcvBuf(s,M,(sizeof(uint32_t)*2));

  672.               rcvBuf(s,M+((sizeof(uint32_t)*2)+lAdrNum()),

  673.                                            n-(sizeof(uint32_t)*2));

  674.               putVar(M);

  675.            }

  676.        }

  677.        break;

  678.      case NET_S2U :

  679.        bcopy((void*)(NET_BUF+1),(void*)&k,sizeof(k));

  680.        /* NTraceData(NET_S2U, k);*/

  681.        NetToStack(s,k);

  682.        c=NET_EOM;

  683.        write(s,(void*)&c,1);

  684.        break;

  685.      default :

  686.        break;

  687.    }

  688. }

  689. 

  690. static int connSock(void)

  691. {

  692.    if ((Sock = socket(AF_INET, SOCK_STREAM,  IPPROTO_TCP)) == -1) {

  693.       messErr(31);

  694.       return 1;

  695.    }

  696.    bcopy(&SinSav,&Sin,sizeof(Sin));

  697.    if(connect(Sock,(struct sockaddr *)&Sin,sizeof(Sin)) < 0) {

  698.       messErr(34);

  699.       return 1;

  700.    }

  701.    return 0; /* OK */

  702. }

  703. 

  704. static void InterruptRpc(int S)

  705. {

  706.    D_Close();

  707.    exit(0);

  708. }

  709. 

  710. void main_Nrpc(void) /* main function for Nrpc client */ 

  711. {

  712. int sock, nsock;

  713. socklen_t ln;

  714. struct sockaddr_in Nsin;

  715. 

  716.     signal(SIGTERM, InterruptRpc);

  717.     if ((sock = socket(AF_INET, SOCK_STREAM,  IPPROTO_TCP)) < 0)

  718.        stopServ(0, "socket",1); 

  719.     bzero(&Nsin,sizeof(Nsin));

  720.     Nsin.sin_family = AF_INET;

  721.     if (bind(sock, (struct sockaddr *)&Nsin, sizeof(Nsin)) < 0) 

  722.        stopServ(0, "bind",2); 

  723.     /* send Nrpc port */

  724.     ln = sizeof(Nsin);

  725.     if (getsockname(sock, (struct sockaddr *)&Nsin, &ln) < 0)

  726.        stopServ(0, "gsname",3); 

  727.     if (connSock()) return;

  728.     sendNrpcPort(Nsin.sin_port);

  729.     if (readMess(Sock) != 2) { messErr(35); return; }

  730.     close(Sock);

  731.     if (*NET_BUF != (NET_NRP+1))  { messErr(40); return; }

  732.     /* listen and wait demands */

  733.     if (listen(sock,5) < 0) stopServ(0, "listen",4); 

  734.     ln = sizeof(Nsin);

  735.     for (;;) {

  736.         if((nsock=accept(sock,(struct sockaddr *)&Nsin,(socklen_t*)&ln)) < 0)

  737.             stopServ(0, "accept",5); 

  738.         net_servrpc(nsock);

  739.         close(nsock);

  740.     }

  741. }

  742. 

  743. int Nrpc_pid=-1;

  744. static void startNrpc(void)

  745. {

  746. 

  747.     if ((Nrpc_pid = fork()) == -1) stopErr("startNrpc","fork");

  748.     if (Nrpc_pid == 0) { /* fils */

  749.        close(0);

  750.        close(1);

  751.        /* close(2); */

  752.        if (Debug) Debug=3;

  753.        D_Reset();

  754.        IF_stack_clear(); /* clear all stacks */

  755.        IF_stackL_clear();

  756.        IF_stackC_clear();

  757.        main_Nrpc();

  758.        exit(1);

  759.     }

  760. }

  761. 

  762. void main_Serv(void) /* main function of Server */

  763. {

  764. int ln, sock, nsock;

  765. 

  766.     initCli();

  767.     if ((sock = socket(AF_INET, SOCK_STREAM,  IPPROTO_TCP)) < 0)

  768.        stopServ(1, "socket",1); 

  769.     bzero(&Sin.sin_addr,sizeof(Sin.sin_addr));

  770.     if (bind(sock, (struct sockaddr *)&Sin, sizeof(Sin)) < 0) 

  771.        stopServ(1, "bind",2); 

  772.     if (listen(sock,5) < 0) stopServ(1, "listen",3); 

  773.     ln = sizeof(Sin);

  774.     for (;;) {

  775.         if((nsock=accept(sock,(struct sockaddr *)&Sin,(socklen_t*)&ln)) < 0)

  776.             stopServ(1, "accept",4); 

  777.         net_service(nsock);

  778.         close(nsock);

  779.     }

  780. }

  781. 

  782. static void startServer(void)

  783. {

  784. int pid;

  785.     if ((pid = fork()) == -1) stopErr("startServer","fork");

  786.     if (pid == 0) { /* fils */

  787.        setsid();

  788.        close(0);

  789.        close(1);

  790.        /* close(2); */

  791.        if (Debug) Debug=2;

  792.        D_Reset();

  793.        close(Sock);

  794.        IF_stack_clear(); /* clear all stacks */

  795.        IF_stackL_clear();

  796.        IF_stackC_clear();

  797.        main_Serv();

  798.     }

  799.     sleep(2); /* wait for server initialization */

  800. }

  801. 

  802. static void IF_netGetVal (char Code)

  803. {

  804. long long v;

  805.    if (NET) {

  806.       if (connSock()) return;

  807.       sendGetStd(Code);

  808.       if (readMess2(Sock,(2+sizeof(v))) != 2+sizeof(v)) { messErr(35); return; }

  809.       close(Sock);

  810.       if (*NET_BUF != (Code+1))  { messErr(40); return; }

  811.       bcopy((void*)(NET_BUF+1),(void*)&v,sizeof(v));

  812.       putLong(v);

  813.    } else messErr(32);

  814. }

  815. 

  816. void IF_netDt (void)

  817. {

  818.     IF_netGetVal(NET_GDT);

  819. }

  820. 

  821. 

  822. void IF_netDepth (void)

  823. {

  824.     IF_netGetVal(NET_DPH);

  825. }

  826. 

  827. void IF_netOff (void)

  828. {

  829.    if (NET) {

  830.       if (connSock()) return;

  831.       sendGetStd(NET_OFF);

  832.       if (readMess(Sock) != 2) { messErr(35); return; }

  833.       close(Sock);

  834.       if (*NET_BUF != (NET_OFF+1))  { messErr(40); return; }

  835.       if (Nrpc_pid > -1) { /* stop Nrpc local server */

  836.           kill(Nrpc_pid, SIGTERM);

  837.           Nrpc_pid=-1;

  838.       }

  839.       NET=0;

  840.    }

  841. }

  842. 

  843. void IF_netOn (void)

  844. {

  845. struct hostent *h;

  846.    if (!isNString(1)) {

  847.         messErr(6); return;

  848.    }

  849.    if (NET) {

  850.         IF_dropC(); return;

  851.    }

  852.    if ((Sock = socket(AF_INET, SOCK_STREAM,  IPPROTO_TCP)) != -1) {

  853.      if(!(h=gethostbyname(NetServer))) {

  854.         messErr(33);

  855.         return;

  856.      }

  857.      bzero(&Sin,sizeof(Sin));

  858.      Sin.sin_family = AF_INET;

  859.      bcopy(h->h_addr,&Sin.sin_addr,h->h_length);

  860.      Sin.sin_port = htons(SERV_PORT);

  861.      bcopy(&Sin,&SinSav,sizeof(Sin));

  862.      if (strcmp(NetServer,LOCALS) == 0) /* localhost */

  863.        SameSaS=1;                        /* same system as server */

  864.      if(connect(Sock,(struct sockaddr *)&Sin,sizeof(Sin)) < 0) {

  865.         if (strcmp(NetServer,LOCALS) != 0) { /* not localhost */

  866.            messErr(34);

  867.            return;

  868.         }

  869.         /* Server is absent : fork it ! */

  870.         startServer();

  871.         if(connect(Sock,(struct sockaddr *)&Sin,sizeof(Sin)) < 0) {

  872.            messErr(34);

  873.            return;

  874.         }

  875.      }

  876.      sendInsc();

  877.      if (readMess(Sock) != 2) { messErr(35); return; }

  878.      close(Sock);

  879.      if (*NET_BUF == (NET_OFF))  { messErr(38); return; }

  880.      if (*NET_BUF != (NET_ON+1))  { messErr(40); return; }

  881.      NET=1; /* net on !! */

  882.      /* start RPC local server */

  883.      startNrpc();

  884.    } else messErr(31);

  885. }

  886. 

  887. void IF_netExec (void)

  888. {

  889. char *sN, *sF;

  890.    if (!isNString(2)) {

  891.         messErr(6); return;

  892.    }

  893.    sN=getString();

  894.    sF=getString();

  895.    if (NET) {

  896.      if (!connSock()) {

  897.         sendC(NET_EXE);

  898.         sendBuf(Sock,_ADDV_NetKey_, sizeof(NetKey));

  899.         sendBuf(Sock,(void*)sN, strlen(sN)+1);

  900.         sendBuf(Sock,(void*)sF, strlen(sF)+1);

  901.         sendC(NET_EOM);

  902.         if (readMess(Sock) != 2) messErr(35);

  903.         close(Sock);

  904.         if (*NET_BUF != (NET_EXE+1)) {

  905.             if (*NET_BUF == (NET_ERR)) messErr(41);

  906.             else messErr(40);

  907.         }

  908.      }

  909.    } 

  910.    free((void*)sN);

  911.    free((void*)sF);

  912. }

  913. 

  914. void IF_netCompile (void)

  915. {

  916. char *sN, *sF;

  917. int fid;

  918.    if (!isNString(2)) {

  919.         messErr(6); return;

  920.    }

  921.    sN=getString();

  922.    sF=getString();

  923.    if ((fid=open(sF,O_RDONLY)) == -1) messErr(43);

  924.    else

  925.    if (NET) {

  926.      if (!connSock()) {

  927.         sendC(NET_PAR);

  928.         sendBuf(Sock,_ADDV_NetKey_, sizeof(NetKey));

  929.         sendBuf(Sock,(void*)sN, strlen(sN)+1);

  930.         sendC(NET_EOM);

  931.         /* wait for invitation */

  932.         if (readMess(Sock) != 2) messErr(35);

  933.         else {

  934.          if (*NET_BUF == (NET_FIL)) {

  935.            sendFile(Sock, fid);

  936.            sendC(NET_EOM);

  937.            if (readMess(Sock) != 2) messErr(35);

  938.          }

  939.         }

  940.         close(Sock);

  941.         if (*NET_BUF != (NET_PAR+1)) {

  942.             if (*NET_BUF == (NET_ERR)) messErr(41);

  943.             else messErr(40);

  944.         }

  945.      }

  946.    } 

  947.    free((void*)sN);

  948.    free((void*)sF);

  949. }

  950. 

  951. void IF_netList (void)

  952. {

  953.    if (NET) {

  954.      if (connSock()) return;

  955.      send1car(Sock,NET_LI);

  956.      readAff(Sock, NET_LI+1);

  957.      close(Sock);

  958.    } 

  959.    printf("<end of net list>\n");

  960. }

  961. 

  962. void IFD_netList (void)

  963. {

  964.     _IFD_BEGIN_

  965.     IF_netList();

  966.     _IFD_END_

  967. }

  968. 

  969. void IF_netStackList (void)

  970. {

  971.    if (NET) {

  972.      if (connSock()) return;

  973.      sendC(NET_SLI);

  974.      sendBuf(Sock,_ADDV_NetKey_, sizeof(NetKey));

  975.      sendC(NET_EOM);

  976.      readAff(Sock, NET_SLI+1);

  977.      close(Sock);

  978.    } 

  979. }

  980. 

  981. void IFD_netStackList (void)

  982. {

  983.     _IFD_BEGIN_

  984.     IF_netStackList();

  985.     _IFD_END_

  986. }

  987. 

  988. void IF_netDropS (void)

  989. {

  990.    if (NET) {

  991.      if (NetKey == UNI_KEY) {

  992.         messErr(37);

  993.         return;

  994.      }

  995.      if (connSock()) return;

  996.      sendC(NET_DRS);

  997.      sendBuf(Sock,_ADDV_NetKey_, sizeof(NetKey));

  998.      sendC(NET_EOM);

  999.      close(Sock);

  1000.    } 

  1001. }

  1002. 

  1003. void IF_netRusage (void)

  1004. {

  1005.    if (NET) {

  1006.      if (connSock()) return;

  1007.      send1car(Sock,NET_RUS);

  1008.      readAff(Sock, NET_RUS+1);

  1009.      close(Sock);

  1010.    } 

  1011.    printf("<end of server ressources usage>\n");

  1012. }

  1013. 

  1014. void IF_netStopS (void)

  1015. {

  1016.    if (NET) {

  1017.      if (connSock()) return;

  1018.      send1car(Sock,NET_STS);

  1019.      if (readMess(Sock) != 2) { messErr(35); return; }

  1020.      close(Sock);

  1021.      if (*NET_BUF != (NET_STS+1))  { messErr(40); return; }

  1022.    } 

  1023. }

  1024. 

  1025. void IF_netU2S(void)

  1026. {

  1027. long n;

  1028.    if (NET) {

  1029.      if (!getParLong(&n)) return;

  1030.      if (n==0) return;

  1031.      if (NetKey == UNI_KEY) {

  1032.         messErr(37);

  1033.         return;

  1034.      }

  1035.      if (connSock()) return;

  1036.      send1car(Sock,NET_U2S);

  1037.      StackToNet(n);

  1038.      sendC(NET_EOM);

  1039.      close(Sock);

  1040.    } else messErr(32);

  1041. }

  1042. 

  1043. void IF_netS2U(void)

  1044. {

  1045. uint32_t n;

  1046. void *M;

  1047. char c;

  1048.    if (NET) {

  1049.      if (connSock()) return;

  1050.      sendC(NET_S2U);

  1051.      sendBuf(Sock,_ADDV_NetKey_, sizeof(NetKey));

  1052.      sendC(NET_EOM);

  1053.      while (1) {

  1054.          read(Sock,(void*)&c,1);

  1055.          if (c == NET_EOM) break;

  1056.          if (c != NET_DAT) {

  1057.               messErr(40); break;

  1058.          }

  1059.          read(Sock,(void*)&n,sizeof(n));

  1060.          /* add the addresse */

  1061.          if ((M = malloc((size_t)n+lAdrNum())) != NULL) {

  1062.               rcvBuf(Sock,M,(sizeof(uint32_t)*2));

  1063.               rcvBuf(Sock,M+((sizeof(uint32_t)*2)+lAdrNum()),

  1064.                                            n-(sizeof(uint32_t)*2));

  1065.               putVar(M);

  1066.          } else stopErr("IF_netS2U","malloc");

  1067.      }

  1068.      close(Sock);

  1069.    } else messErr(32);

  1070. }

  1071. 

  1072.