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.
8 Commits
1 Branch
631 KiB
 
 
 
 
Tree: 5d88e120ca
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5d88e120ca'
${ noResults }
Nife_v0/src/net.c

1060 lines
24 KiB
Raw Blame History 

  1. /* Copyright (C) 2011-2015  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.      b++;

  261.      if (b>f) { b--; break; }

  262.    }

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

  264.    b++;

  265.    return(b-NET_BUF);

  266. }

  267. 

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

  269. {

  270. char  b[2];

  271. int ok=0;

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

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

  274.    while (*b != NET_EOM) {

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

  276.          else {

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

  278.          }

  279.    }

  280. }

  281. 

  282. static void sendC(char c)

  283. {

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

  285. }

  286. 

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

  288. {

  289.     write(s,b,no);

  290. }

  291. 

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

  293. {

  294. int r,ar;

  295. void *t;

  296.     ar = no;

  297.     r = 0;

  298.     t = b;

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

  300.         if (r<0) break;

  301.         ar -= r;

  302.         t += r;

  303.     }

  304. }

  305. 

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

  307. {

  308. char c;

  309.     c=NET_DAT;

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

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

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

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

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

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

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

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

  318. }

  319. 

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

  321. {

  322.     sendData(Sock,b,n);

  323. }

  324. 

  325. void sendFile(int s, int fid)

  326. {

  327. int n;

  328. char Buf[LNBUF];

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

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

  331.    close(fid);

  332. }

  333. 

  334. static void sendInsc(void)

  335. {

  336. char *s;

  337. struct Mess1 M1;

  338. uint32_t scs;

  339. struct timeval tv;

  340. long long v;

  341. 

  342.     scs = getScs();

  343.     s = getString();

  344.     M1.pid = getpid();

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

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

  347.     if (SameSaS) sendC(NET_ON);

  348.     else sendC(NET_ONR);

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

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

  351.     sendC(NET_EOM);

  352.     /* update NetName */

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

  354.     NetName=s;

  355.     if (SameSaS==0) {

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

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

  358.             gettimeofday(&tv,NULL);

  359.             v=Nife_time(tv);

  360.             sendC(NET_CAL+1);

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

  362.             sendC(NET_EOM);

  363.          }

  364.       }

  365.     } else SameSaS=0;

  366. }

  367. 

  368. static void sendGetStd(char Code)

  369. {

  370. struct Mess1 M1;

  371.     switch(Code) {

  372.       case NET_OFF :

  373.       case NET_GDT :

  374.          M1.pid = getpid();

  375.          break;

  376.       default :

  377.          M1.pid = NetKey;

  378.     }

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

  380.     sendC(Code);

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

  382.     sendC(NET_EOM);

  383. }

  384. 

  385. static void sendNrpcPort(in_port_t P)

  386. {

  387. struct Mess1 M1;

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

  389.     M1.port = P;

  390.     sendC(NET_NRP);

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

  392.     sendC(NET_EOM);

  393. }

  394. 

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

  396. {

  397. char b[2];

  398.     b[0]=c;

  399.     b[1]=NET_EOM;

  400.     write(s,b,2); 

  401. }

  402. 

  403. void NTraceM1(char * A)

  404. {

  405. struct Mess1 M1;

  406. char buf[50];

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

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

  409.    D_Trace(buf);

  410. }

  411. 

  412. void NTraceData(char A, long n)

  413. {

  414. char buf[50];

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

  416.    D_Trace(buf);

  417. }

  418. 

  419. static void RemotExecBegin(long long k)

  420. {

  421.    putLong(k);

  422.    IF_NetKey();

  423.    IF_netS2U();

  424.    IF_netDropS();

  425. }

  426. 

  427. static void RemotExecEnd(void)

  428. {

  429.    if (noErr()) {

  430.       razErr();

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

  432.       IF_stackL_clear();

  433.       IF_stackC_clear();

  434.       IF_NetErrVal();

  435.    }

  436.    IF_depth();

  437.    IF_netU2S();

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

  439.    IF_stackL_clear();

  440.    IF_stackC_clear();

  441. }

  442. 

  443. static void net_servrpc(int s)

  444. {

  445. int i, j, fid;

  446. uint32_t k;

  447. char *sF, nF[30];

  448.    i=readMess(s);

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

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

  451.    switch(*NET_BUF) {

  452.      case NET_OFF :

  453.        send1car(s, NET_OFF+1);

  454.        D_Close();

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

  456.        break;

  457.      case NET_EXE :

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

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

  460.        /* execute the function call */

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

  462.        RemotExecBegin((long long)k);

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

  464.        RemotExecEnd();

  465.        break;

  466.      case NET_PAR :

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

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

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

  470.           j=1;

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

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

  473.                  j=0; i--;

  474.                }

  475.                write(fid, NET_BUF, i);

  476.           }

  477.           close(fid);

  478.           RemotExecBegin((long long)k);

  479.           compileFile(nF);

  480.           RemotExecEnd();

  481.           unlink(nF);

  482.        }

  483.        break;

  484.      default :

  485.        break;

  486.    }

  487. }

  488. 

  489. 

  490. static void net_service(int s)

  491. {

  492. int i, CalDT=0;

  493. uint32_t n, k,scs;

  494. void *M;

  495. struct Mess1 M1;

  496. struct timeval tv;

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

  498. char c, *sN, *sF;

  499. 

  500.    i=readMess(s);

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

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

  503.    switch(*NET_BUF) {

  504.      case NET_ONR :

  505.        CalDT=1;

  506.      case NET_ON :

  507.        /* NTraceM1(NET_BUF); */

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

  509.        scs = getScs();

  510.        if (k==scs) {

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

  512.           if (CalDT) {

  513.              gettimeofday(&tv,NULL);

  514.              send1car(s, NET_CAL);

  515.              v1=Nife_time(tv);

  516.              i=readMess(s);

  517.              gettimeofday(&tv,NULL);

  518.              v2=Nife_time(tv);

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

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

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

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

  523.              }

  524.              else

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

  526.              send1car(s, NET_ON+1);

  527.           } else {

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

  529.              send1car(s, NET_ON+1);

  530.           }

  531.        }

  532.        else 

  533.           send1car(s, NET_OFF);

  534.        break;

  535.      case NET_OFF :

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

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

  538.        send1car(s, NET_OFF+1);

  539.        if (STS) {

  540.           if (NCli == 0) {

  541.              D_Close();

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

  543.           }

  544.           STS=0;

  545.        }

  546.        break;

  547.      case NET_NRP :

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

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

  550.        send1car(s, NET_NRP+1);

  551.        break;

  552.      case NET_DPH :

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

  554.        dt=NetDepth(M1.pid);

  555.        c=*NET_BUF+1;

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

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

  558.        c=NET_EOM;

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

  560.        break;

  561.      case NET_GDT :

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

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

  564.        c=*NET_BUF+1;

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

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

  567.        c=NET_EOM;

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

  569.        break;

  570.      case NET_EXE :

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

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

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

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

  575.        i=getCliId(sN);

  576.        if (i>=0) {

  577.           send1car(s, NET_EXE+1);

  578.           /* send the call */

  579.           if (!connSock2(i)) {

  580.              sendC(NET_EXE);

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

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

  583.              sendC(NET_EOM);

  584.           }

  585.        }

  586.        else send1car(s, NET_ERR);

  587.        break;

  588.      case NET_PAR :

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

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

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

  592.        i=getCliId(sN);

  593.        if (i>=0) {

  594.           /* connect to client */

  595.           if (!connSock2(i)) {

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

  597.              sendC(NET_PAR);

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

  599.              sendC(NET_EOM);

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

  601.                sendBuf(Sock, NET_BUF, i);

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

  603.              }

  604.              send1car(s, NET_PAR+1);

  605.           }

  606.           else send1car(s, NET_ERR);

  607.        }

  608.        else send1car(s, NET_ERR);

  609.        break;

  610.      case NET_STS :

  611.        STS=1;

  612.        send1car(s, NET_STS+1);

  613.        break;

  614.      case NET_DRS :

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

  616.        IF_netDrop(k);

  617.        break;

  618.      case NET_LI :

  619.        c=*NET_BUF+1;

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

  621.        dup2(s,1);

  622.        listCli();

  623.        close(1);

  624.        c=NET_EOM;

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

  626.        break;

  627.      case NET_SLI :

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

  629.        c=*NET_BUF+1;

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

  631.        dup2(s,1);

  632.        IF_show_netStack(k);

  633.        close(1);

  634.        c=NET_EOM;

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

  636.        break;

  637.      case NET_RUS :

  638.        c=*NET_BUF+1;

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

  640.        dup2(s,1);

  641.        IF_resUsage();

  642.        close(1);

  643.        c=NET_EOM;

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

  645.        break;

  646.      case NET_U2S :

  647.        while (1) {

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

  649.            if (c == NET_EOM) break;

  650.            if (c != NET_DAT) {

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

  652.            }

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

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

  655.            /* add the addresse */

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

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

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

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

  660.               putVar(M);

  661.            }

  662.        }

  663.        break;

  664.      case NET_S2U :

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

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

  667.        NetToStack(s,k);

  668.        c=NET_EOM;

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

  670.        break;

  671.      default :

  672.        break;

  673.    }

  674. }

  675. 

  676. static int connSock(void)

  677. {

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

  679.       messErr(31);

  680.       return 1;

  681.    }

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

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

  684.       messErr(34);

  685.       return 1;

  686.    }

  687.    return 0; /* OK */

  688. }

  689. 

  690. static void InterruptRpc(int S)

  691. {

  692.    D_Close();

  693.    exit(0);

  694. }

  695. 

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

  697. {

  698. int sock, nsock;

  699. socklen_t ln;

  700. struct sockaddr_in Nsin;

  701. 

  702.     signal(SIGTERM, InterruptRpc);

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

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

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

  706.     Nsin.sin_family = AF_INET;

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

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

  709.     /* send Nrpc port */

  710.     ln = sizeof(Nsin);

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

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

  713.     if (connSock()) return;

  714.     sendNrpcPort(Nsin.sin_port);

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

  716.     close(Sock);

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

  718.     /* listen and wait demands */

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

  720.     ln = sizeof(Nsin);

  721.     for (;;) {

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

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

  724.         net_servrpc(nsock);

  725.         close(nsock);

  726.     }

  727. }

  728. 

  729. int Nrpc_pid=-1;

  730. static void startNrpc(void)

  731. {

  732. 

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

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

  735.        close(0);

  736.        close(1);

  737.        /* close(2); */

  738.        if (Debug) Debug=3;

  739.        D_Reset();

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

  741.        IF_stackL_clear();

  742.        IF_stackC_clear();

  743.        main_Nrpc();

  744.        exit(1);

  745.     }

  746. }

  747. 

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

  749. {

  750. int ln, sock, nsock;

  751. 

  752.     initCli();

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

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

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

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

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

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

  759.     ln = sizeof(Sin);

  760.     for (;;) {

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

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

  763.         net_service(nsock);

  764.         close(nsock);

  765.     }

  766. }

  767. 

  768. static void startServer(void)

  769. {

  770. int pid;

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

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

  773.        setsid();

  774.        close(0);

  775.        close(1);

  776.        /* close(2); */

  777.        if (Debug) Debug=2;

  778.        D_Reset();

  779.        close(Sock);

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

  781.        IF_stackL_clear();

  782.        IF_stackC_clear();

  783.        main_Serv();

  784.     }

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

  786. }

  787. 

  788. static void IF_netGetVal (char Code)

  789. {

  790. long long v;

  791.    if (NET) {

  792.       if (connSock()) return;

  793.       sendGetStd(Code);

  794.       if (readMess(Sock) != 2+sizeof(v)) { messErr(35); return; }

  795.       close(Sock);

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

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

  798.       putLong(v);

  799.    } else messErr(32);

  800. }

  801. 

  802. void IF_netDt (void)

  803. {

  804.     IF_netGetVal(NET_GDT);

  805. }

  806. 

  807. 

  808. void IF_netDepth (void)

  809. {

  810.     IF_netGetVal(NET_DPH);

  811. }

  812. 

  813. void IF_netOff (void)

  814. {

  815.    if (NET) {

  816.       if (connSock()) return;

  817.       sendGetStd(NET_OFF);

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

  819.       close(Sock);

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

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

  822.           kill(Nrpc_pid, SIGTERM);

  823.           Nrpc_pid=-1;

  824.       }

  825.       NET=0;

  826.    }

  827. }

  828. 

  829. void IF_netOn (void)

  830. {

  831. struct hostent *h;

  832.    if (!isNString(1)) {

  833.         messErr(6); return;

  834.    }

  835.    if (NET) {

  836.         IF_dropC(); return;

  837.    }

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

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

  840.         messErr(33);

  841.         return;

  842.      }

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

  844.      Sin.sin_family = AF_INET;

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

  846.      Sin.sin_port = htons(SERV_PORT);

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

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

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

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

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

  852.            messErr(34);

  853.            return;

  854.         }

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

  856.         startServer();

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

  858.            messErr(34);

  859.            return;

  860.         }

  861.      }

  862.      sendInsc();

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

  864.      close(Sock);

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

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

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

  868.      /* start RPC local server */

  869.      startNrpc();

  870.    } else messErr(31);

  871. }

  872. 

  873. void IF_netExec (void)

  874. {

  875. char *sN, *sF;

  876.    if (!isNString(2)) {

  877.         messErr(6); return;

  878.    }

  879.    sN=getString();

  880.    sF=getString();

  881.    if (NET) {

  882.      if (!connSock()) {

  883.         sendC(NET_EXE);

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

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

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

  887.         sendC(NET_EOM);

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

  889.         close(Sock);

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

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

  892.             else messErr(40);

  893.         }

  894.      }

  895.    } 

  896.    free((void*)sN);

  897.    free((void*)sF);

  898. }

  899. 

  900. void IF_netCompile (void)

  901. {

  902. char *sN, *sF;

  903. int fid;

  904.    if (!isNString(2)) {

  905.         messErr(6); return;

  906.    }

  907.    sN=getString();

  908.    sF=getString();

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

  910.    else

  911.    if (NET) {

  912.      if (!connSock()) {

  913.         sendC(NET_PAR);

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

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

  916.         sendC(NET_EOM);

  917.         /* wait for invitation */

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

  919.         else {

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

  921.            sendFile(Sock, fid);

  922.            sendC(NET_EOM);

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

  924.          }

  925.         }

  926.         close(Sock);

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

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

  929.             else messErr(40);

  930.         }

  931.      }

  932.    } 

  933.    free((void*)sN);

  934.    free((void*)sF);

  935. }

  936. 

  937. void IF_netList (void)

  938. {

  939.    if (NET) {

  940.      if (connSock()) return;

  941.      send1car(Sock,NET_LI);

  942.      readAff(Sock, NET_LI+1);

  943.      close(Sock);

  944.    } 

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

  946. }

  947. 

  948. void IFD_netList (void)

  949. {

  950.     _IFD_BEGIN_

  951.     IF_netList();

  952.     _IFD_END_

  953. }

  954. 

  955. void IF_netStackList (void)

  956. {

  957.    if (NET) {

  958.      if (connSock()) return;

  959.      sendC(NET_SLI);

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

  961.      sendC(NET_EOM);

  962.      readAff(Sock, NET_SLI+1);

  963.      close(Sock);

  964.    } 

  965. }

  966. 

  967. void IFD_netStackList (void)

  968. {

  969.     _IFD_BEGIN_

  970.     IF_netStackList();

  971.     _IFD_END_

  972. }

  973. 

  974. void IF_netDropS (void)

  975. {

  976.    if (NET) {

  977.      if (NetKey == UNI_KEY) {

  978.         messErr(37);

  979.         return;

  980.      }

  981.      if (connSock()) return;

  982.      sendC(NET_DRS);

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

  984.      sendC(NET_EOM);

  985.      close(Sock);

  986.    } 

  987. }

  988. 

  989. void IF_netRusage (void)

  990. {

  991.    if (NET) {

  992.      if (connSock()) return;

  993.      send1car(Sock,NET_RUS);

  994.      readAff(Sock, NET_RUS+1);

  995.      close(Sock);

  996.    } 

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

  998. }

  999. 

  1000. void IF_netStopS (void)

  1001. {

  1002.    if (NET) {

  1003.      if (connSock()) return;

  1004.      send1car(Sock,NET_STS);

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

  1006.      close(Sock);

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

  1008.    } 

  1009. }

  1010. 

  1011. void IF_netU2S(void)

  1012. {

  1013. long n;

  1014.    if (NET) {

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

  1016.      if (n==0) return;

  1017.      if (NetKey == UNI_KEY) {

  1018.         messErr(37);

  1019.         return;

  1020.      }

  1021.      if (connSock()) return;

  1022.      send1car(Sock,NET_U2S);

  1023.      StackToNet(n);

  1024.      sendC(NET_EOM);

  1025.      close(Sock);

  1026.    } else messErr(32);

  1027. }

  1028. 

  1029. void IF_netS2U(void)

  1030. {

  1031. uint32_t n;

  1032. void *M;

  1033. char c;

  1034.    if (NET) {

  1035.      if (connSock()) return;

  1036.      sendC(NET_S2U);

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

  1038.      sendC(NET_EOM);

  1039.      while (1) {

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

  1041.          if (c == NET_EOM) break;

  1042.          if (c != NET_DAT) {

  1043.               messErr(40); break;

  1044.          }

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

  1046.          /* add the addresse */

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

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

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

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

  1051.               putVar(M);

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

  1053.      }

  1054.      close(Sock);

  1055.    } else messErr(32);

  1056. }

  1057. 

  1058.