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

1035 lines
24 KiB
Raw Blame History 

  1. /* Copyright (C) 2011-2014  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_Trace(NET_BUF); */

  451.    switch(*NET_BUF) {

  452.      case NET_OFF :

  453.        send1car(s, NET_OFF+1);

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

  455.        break;

  456.      case NET_EXE :

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

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

  459.        /* execute the function call */

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

  461.        RemotExecBegin((long long)k);

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

  463.        RemotExecEnd();

  464.        break;

  465.      case NET_PAR :

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

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

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

  469.           j=1;

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

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

  472.                  j=0; i--;

  473.                }

  474.                write(fid, NET_BUF, i);

  475.           }

  476.           close(fid);

  477.           RemotExecBegin((long long)k);

  478.           compileFile(nF);

  479.           RemotExecEnd();

  480.           unlink(nF);

  481.        }

  482.        break;

  483.      default :

  484.        break;

  485.    }

  486. }

  487. 

  488. 

  489. static void net_service(int s)

  490. {

  491. int i, CalDT=0;

  492. uint32_t n, k,scs;

  493. void *M;

  494. struct Mess1 M1;

  495. struct timeval tv;

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

  497. char c, *sN, *sF;

  498. 

  499.    i=readMess(s);

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

  501.    /* D_Trace(NET_BUF); */

  502.    switch(*NET_BUF) {

  503.      case NET_ONR :

  504.        CalDT=1;

  505.      case NET_ON :

  506.        /* NTraceM1(NET_BUF); */

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

  508.        scs = getScs();

  509.        if (k==scs) {

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

  511.           if (CalDT) {

  512.              gettimeofday(&tv,NULL);

  513.              send1car(s, NET_CAL);

  514.              v1=Nife_time(tv);

  515.              i=readMess(s);

  516.              gettimeofday(&tv,NULL);

  517.              v2=Nife_time(tv);

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

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

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

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

  522.              }

  523.              else

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

  525.              send1car(s, NET_ON+1);

  526.           } else {

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

  528.              send1car(s, NET_ON+1);

  529.           }

  530.        }

  531.        else 

  532.           send1car(s, NET_OFF);

  533.        break;

  534.      case NET_OFF :

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

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

  537.        send1car(s, NET_OFF+1);

  538.        if (STS) {

  539.           if (NCli == 0) exit(0); /* stop the server */

  540.           STS=0;

  541.        }

  542.        break;

  543.      case NET_NRP :

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

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

  546.        send1car(s, NET_NRP+1);

  547.        break;

  548.      case NET_DPH :

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

  550.        dt=NetDepth(M1.pid);

  551.        c=*NET_BUF+1;

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

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

  554.        c=NET_EOM;

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

  556.        break;

  557.      case NET_GDT :

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

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

  560.        c=*NET_BUF+1;

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

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

  563.        c=NET_EOM;

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

  565.        break;

  566.      case NET_EXE :

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

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

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

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

  571.        i=getCliId(sN);

  572.        if (i>=0) {

  573.           send1car(s, NET_EXE+1);

  574.           /* send the call */

  575.           if (!connSock2(i)) {

  576.              sendC(NET_EXE);

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

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

  579.              sendC(NET_EOM);

  580.           }

  581.        }

  582.        else send1car(s, NET_ERR);

  583.        break;

  584.      case NET_PAR :

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

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

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

  588.        i=getCliId(sN);

  589.        if (i>=0) {

  590.           /* connect to client */

  591.           if (!connSock2(i)) {

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

  593.              sendC(NET_PAR);

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

  595.              sendC(NET_EOM);

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

  597.                sendBuf(Sock, NET_BUF, i);

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

  599.              }

  600.              send1car(s, NET_PAR+1);

  601.           }

  602.           else send1car(s, NET_ERR);

  603.        }

  604.        else send1car(s, NET_ERR);

  605.        break;

  606.      case NET_STS :

  607.        STS=1;

  608.        send1car(s, NET_STS+1);

  609.        break;

  610.      case NET_DRS :

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

  612.        IF_netDrop(k);

  613.        break;

  614.      case NET_LI :

  615.        c=*NET_BUF+1;

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

  617.        dup2(s,1);

  618.        listCli();

  619.        close(1);

  620.        c=NET_EOM;

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

  622.        break;

  623.      case NET_SLI :

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

  625.        c=*NET_BUF+1;

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

  627.        dup2(s,1);

  628.        IF_show_netStack(k);

  629.        close(1);

  630.        c=NET_EOM;

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

  632.        break;

  633.      case NET_RUS :

  634.        c=*NET_BUF+1;

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

  636.        dup2(s,1);

  637.        IF_resUsage();

  638.        close(1);

  639.        c=NET_EOM;

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

  641.        break;

  642.      case NET_U2S :

  643.        while (1) {

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

  645.            if (c == NET_EOM) break;

  646.            if (c != NET_DAT) {

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

  648.            }

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

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

  651.            /* add the addresse */

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

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

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

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

  656.               putVar(M);

  657.            }

  658.        }

  659.        break;

  660.      case NET_S2U :

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

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

  663.        NetToStack(s,k);

  664.        c=NET_EOM;

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

  666.        break;

  667.      default :

  668.        break;

  669.    }

  670. }

  671. 

  672. static int connSock(void)

  673. {

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

  675.       messErr(31);

  676.       return 1;

  677.    }

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

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

  680.       messErr(34);

  681.       return 1;

  682.    }

  683.    return 0; /* OK */

  684. }

  685. 

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

  687. {

  688. int sock, nsock;

  689. socklen_t ln;

  690. struct sockaddr_in Nsin;

  691. 

  692.     signal(SIGTERM, SIG_DFL);

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

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

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

  696.     Nsin.sin_family = AF_INET;

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

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

  699.     /* send Nrpc port */

  700.     ln = sizeof(Nsin);

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

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

  703.     if (connSock()) return;

  704.     sendNrpcPort(Nsin.sin_port);

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

  706.     close(Sock);

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

  708.     /* listen and wait demands */

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

  710.     ln = sizeof(Nsin);

  711.     for (;;) {

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

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

  714.         net_servrpc(nsock);

  715.         close(nsock);

  716.     }

  717. }

  718. 

  719. int Nrpc_pid=-1;

  720. static void startNrpc(void)

  721. {

  722. 

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

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

  725.        close(0);

  726.        close(1);

  727.        /* close(2); */

  728.        D_Reset();

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

  730.        IF_stackL_clear();

  731.        IF_stackC_clear();

  732.        main_Nrpc();

  733.        exit(1);

  734.     }

  735. }

  736. 

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

  738. {

  739. int ln, sock, nsock;

  740. 

  741.     initCli();

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

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

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

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

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

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

  748.     ln = sizeof(Sin);

  749.     for (;;) {

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

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

  752.         net_service(nsock);

  753.         close(nsock);

  754.     }

  755. }

  756. 

  757. static void startServer(void)

  758. {

  759. int pid;

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

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

  762.        setsid();

  763.        close(0);

  764.        close(1);

  765.        /* close(2); */

  766.        D_Reset();

  767.        close(Sock);

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

  769.        IF_stackL_clear();

  770.        IF_stackC_clear();

  771.        main_Serv();

  772.     }

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

  774. }

  775. 

  776. static void IF_netGetVal (char Code)

  777. {

  778. long long v;

  779.    if (NET) {

  780.       if (connSock()) return;

  781.       sendGetStd(Code);

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

  783.       close(Sock);

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

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

  786.       putLong(v);

  787.    } else messErr(32);

  788. }

  789. 

  790. void IF_netDt (void)

  791. {

  792.     IF_netGetVal(NET_GDT);

  793. }

  794. 

  795. 

  796. void IF_netDepth (void)

  797. {

  798.     IF_netGetVal(NET_DPH);

  799. }

  800. 

  801. void IF_netOff (void)

  802. {

  803.    if (NET) {

  804.       if (connSock()) return;

  805.       sendGetStd(NET_OFF);

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

  807.       close(Sock);

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

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

  810.           kill(Nrpc_pid, SIGTERM);

  811.           Nrpc_pid=-1;

  812.       }

  813.       NET=0;

  814.    }

  815. }

  816. 

  817. void IF_netOn (void)

  818. {

  819. struct hostent *h;

  820.    if (!isNString(1)) {

  821.         messErr(6); return;

  822.    }

  823.    if (NET) {

  824.         IF_dropC(); return;

  825.    }

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

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

  828.         messErr(33);

  829.         return;

  830.      }

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

  832.      Sin.sin_family = AF_INET;

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

  834.      Sin.sin_port = htons(SERV_PORT);

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

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

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

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

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

  840.            messErr(34);

  841.            return;

  842.         }

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

  844.         startServer();

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

  846.            messErr(34);

  847.            return;

  848.         }

  849.      }

  850.      sendInsc();

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

  852.      close(Sock);

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

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

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

  856.      /* start RPC local server */

  857.      startNrpc();

  858.    } else messErr(31);

  859. }

  860. 

  861. void IF_netExec (void)

  862. {

  863. char *sN, *sF;

  864.    if (!isNString(2)) {

  865.         messErr(6); return;

  866.    }

  867.    sN=getString();

  868.    sF=getString();

  869.    if (NET) {

  870.      if (!connSock()) {

  871.         sendC(NET_EXE);

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

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

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

  875.         sendC(NET_EOM);

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

  877.         close(Sock);

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

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

  880.             else messErr(40);

  881.         }

  882.      }

  883.    } 

  884.    free((void*)sN);

  885.    free((void*)sF);

  886. }

  887. 

  888. void IF_netCompile (void)

  889. {

  890. char *sN, *sF;

  891. int fid;

  892.    if (!isNString(2)) {

  893.         messErr(6); return;

  894.    }

  895.    sN=getString();

  896.    sF=getString();

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

  898.    else

  899.    if (NET) {

  900.      if (!connSock()) {

  901.         sendC(NET_PAR);

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

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

  904.         sendC(NET_EOM);

  905.         /* wait for invitation */

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

  907.         else {

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

  909.            sendFile(Sock, fid);

  910.            sendC(NET_EOM);

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

  912.          }

  913.         }

  914.         close(Sock);

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

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

  917.             else messErr(40);

  918.         }

  919.      }

  920.    } 

  921.    free((void*)sN);

  922.    free((void*)sF);

  923. }

  924. 

  925. void IF_netList (void)

  926. {

  927.    if (NET) {

  928.      if (connSock()) return;

  929.      send1car(Sock,NET_LI);

  930.      readAff(Sock, NET_LI+1);

  931.      close(Sock);

  932.    } 

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

  934. }

  935. 

  936. void IF_netStackList (void)

  937. {

  938.    if (NET) {

  939.      if (connSock()) return;

  940.      sendC(NET_SLI);

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

  942.      sendC(NET_EOM);

  943.      readAff(Sock, NET_SLI+1);

  944.      close(Sock);

  945.    } 

  946.    /* printf("<end of net stack>\n"); */

  947. }

  948. 

  949. void IF_netDropS (void)

  950. {

  951.    if (NET) {

  952.      if (NetKey == UNI_KEY) {

  953.         messErr(37);

  954.         return;

  955.      }

  956.      if (connSock()) return;

  957.      sendC(NET_DRS);

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

  959.      sendC(NET_EOM);

  960.      close(Sock);

  961.    } 

  962. }

  963. 

  964. void IF_netRusage (void)

  965. {

  966.    if (NET) {

  967.      if (connSock()) return;

  968.      send1car(Sock,NET_RUS);

  969.      readAff(Sock, NET_RUS+1);

  970.      close(Sock);

  971.    } 

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

  973. }

  974. 

  975. void IF_netStopS (void)

  976. {

  977.    if (NET) {

  978.      if (connSock()) return;

  979.      send1car(Sock,NET_STS);

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

  981.      close(Sock);

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

  983.    } 

  984. }

  985. 

  986. void IF_netU2S(void)

  987. {

  988. long n;

  989.    if (NET) {

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

  991.      if (n==0) return;

  992.      if (NetKey == UNI_KEY) {

  993.         messErr(37);

  994.         return;

  995.      }

  996.      if (connSock()) return;

  997.      send1car(Sock,NET_U2S);

  998.      StackToNet(n);

  999.      sendC(NET_EOM);

  1000.      close(Sock);

  1001.    } else messErr(32);

  1002. }

  1003. 

  1004. void IF_netS2U(void)

  1005. {

  1006. uint32_t n;

  1007. void *M;

  1008. char c;

  1009.    if (NET) {

  1010.      if (connSock()) return;

  1011.      sendC(NET_S2U);

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

  1013.      sendC(NET_EOM);

  1014.      while (1) {

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

  1016.          if (c == NET_EOM) break;

  1017.          if (c != NET_DAT) {

  1018.               messErr(40); break;

  1019.          }

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

  1021.          /* add the addresse */

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

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

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

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

  1026.               putVar(M);

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

  1028.      }

  1029.      close(Sock);

  1030.    } else messErr(32);

  1031. }

  1032. 

  1033.