[BACK]Return to ox.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / ox_toolkit

Diff for /OpenXM/src/ox_toolkit/ox.c between version 1.3 and 1.8

version 1.3, 1999/12/14 09:29:13 version 1.8, 2000/01/19 19:46:42
Line 1 
Line 1 
 /* -*- mode: C; coding: euc-japan -*- */  /* -*- mode: C; coding: euc-japan -*- */
 /* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.2 1999/12/13 02:27:15 ohara Exp $ */  /* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.7 2000/01/17 19:55:55 ohara Exp $ */
   
 /*  /*
 関数の名前付け規約(その2):     This module includes functions for sending/receiveng CMO's.
 (1) receive_cmo 関数はCMOタグとデータ本体を受信する. この関数は CMOタグの     Some commnets is written in Japanese by the EUC-JP coded
 値が事前に分からないときに使用する. 返り値として、cmo へのポインタを返す.     character set.
 (2) receive_cmo_XXX 関数は, CMOタグを親の関数で受信してから呼び出される関  
 数で、データ本体のみを受信し、cmo_XXX へのポインタを返す.  しかも、  
 関数内部で new_cmo_XXX 関数を呼び出す.  
 (3) send_cmo 関数はCMOタグとデータ本体を送信する.  
 (4) send_cmo_XXX 関数はCMOタグを親の関数で送信してから呼び出される関数で、  
 データ本体のみを送信する.  
   
 ----  
 (5) receive_ox_XXX 関数は存在しない(作らない).  receive_cmo を利用する.  
 (6) send_ox_XXX 関数は OX タグを含めて送信する.  
 (7) ox_XXX 関数は一連の送受信を含むより抽象的な操作を表現する.  
 ox_XXX 関数は、第一引数として、ox_file_t型の変数 sv をとる.  
   
 (8) YYY_cmo 関数と YYY_cmo_XXX 関数の関係は次の通り:  
 まず YYY_cmo 関数で cmo のタグを処理し、タグを除いた残りの部分を  
 YYY_cmo_XXX 関数が処理する.  cmo の内部に cmo_ZZZ へのポインタが  
 あるときには、その種類によらずに YYY_cmo 関数を呼び出す.  
 */  */
   
   
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <unistd.h>  #include <unistd.h>
 #include <errno.h>  #include <errno.h>
 #include <fcntl.h>  #include <fcntl.h>
 #include <gmp.h>  
 #include <unistd.h>  
 #include <sys/file.h>  #include <sys/file.h>
   #include <gmp.h>
   
 #include "mysocket.h"  #include "mysocket.h"
 #include "ox.h"  #include "ox.h"
Line 105  int set_current_fd(int fd)
Line 88  int set_current_fd(int fd)
         current_fd = fd;          current_fd = fd;
 }  }
   
 /* hook 関数 */  /* hook functions. (yet not implemented) */
 static hook_t hook_before_send_cmo = NULL;  static hook_t hook_before_send_cmo = NULL;
 static hook_t hook_after_send_cmo  = NULL;  static hook_t hook_after_send_cmo  = NULL;
   
Line 135  static cmo *call_hook_after_send_cmo(int fd, cmo *c)
Line 118  static cmo *call_hook_after_send_cmo(int fd, cmo *c)
         return c;          return c;
 }  }
   
 /* エラーハンドリングのため */  /* Handling an error. */
 static int current_received_serial = 0;  static int current_received_serial = 0;
   
 /* エラーを起こしたときにサーバは次を呼び出す.  */  /* If an error object be needed, then a server call the following function. */
 cmo_error2* make_error_object(int err_code, cmo *ob)  cmo_error2* make_error_object(int err_code, cmo *ob)
 {  {
     cmo_list* li = new_cmo_list();      cmo_list* li = new_cmo_list();
Line 149  cmo_error2* make_error_object(int err_code, cmo *ob)
Line 132  cmo_error2* make_error_object(int err_code, cmo *ob)
     return new_cmo_error2((cmo *)li);      return new_cmo_error2((cmo *)li);
 }  }
   
 /* add at Mon Sep  7 15:51:28 JST 1998 */  
 #define DEFAULT_SERIAL_NUMBER 0x0000ffff  #define DEFAULT_SERIAL_NUMBER 0x0000ffff
 #define receive_serial_number(x)   (receive_int32(x))  #define receive_serial_number(x)   (receive_int32(x))
   
 /* 新しいシリアル番号を得る */  /* getting a next serial number. */
 int next_serial()  int next_serial()
 {  {
     static int serial_number = DEFAULT_SERIAL_NUMBER;      static int serial_number = DEFAULT_SERIAL_NUMBER;
     return serial_number++;      return serial_number++;
 }  }
   
 /* int32 型のオブジェクトを送信する.  */  /* sending an object of int32 type. (not equal to cmo_int32 type)  */
 int send_int32(int fd, int int32)  int send_int32(int fd, int int32)
 {  {
     int32 = htonl(int32);      int32 = htonl(int32);
     return write(fd, &int32, sizeof(int));      return write(fd, &int32, sizeof(int));
 }  }
   
 /* int32 型のオブジェクトを受信する.  */  /* receiving an object of int32 type. (not equal to cmo_int32 type)  */
 int receive_int32(int fd)  int receive_int32(int fd)
 {  {
     int tag;      int tag;
Line 175  int receive_int32(int fd)
Line 157  int receive_int32(int fd)
     return ntohl(tag);      return ntohl(tag);
 }  }
   
 /* (OX_tag, serial number) を受信する.  */  /* receiving an (OX_tag, serial number)  */
 int receive_ox_tag(int fd)  int receive_ox_tag(int fd)
 {  {
     int serial;      int serial;
Line 184  int receive_ox_tag(int fd)
Line 166  int receive_ox_tag(int fd)
     return tag;      return tag;
 }  }
   
 /* (OX_tag, serial number) を送信する.   */  /* sending an (OX_tag, serial number)  */
 int send_ox_tag(int fd, int tag)  int send_ox_tag(int fd, int tag)
 {  {
     send_int32(fd, tag);      send_int32(fd, tag);
     return send_int32(fd, next_serial());      return send_int32(fd, next_serial());
 }  }
   
 /* CMO_LIST 関係の関数群 */  /* functions for a cmo_list */
 cell* new_cell()  cell* new_cell()
 {  {
     cell* h = malloc(sizeof(cell));      cell* h = malloc(sizeof(cell));
Line 239  int length_cmo_list(cmo_list* this)
Line 221  int length_cmo_list(cmo_list* this)
     return this->length;      return this->length;
 }  }
   
 /** receive_cmo_XXX 関数群 **/  /* functions named receive_cmo_*. */
 static cmo_null* receive_cmo_null(int fd)  static cmo_null* receive_cmo_null(int fd)
 {  {
     return new_cmo_null();      return new_cmo_null();
Line 315  static cmo_dms_generic* receive_cmo_dms_generic(int fd
Line 297  static cmo_dms_generic* receive_cmo_dms_generic(int fd
 static cmo_ring_by_name* receive_cmo_ring_by_name(int fd)  static cmo_ring_by_name* receive_cmo_ring_by_name(int fd)
 {  {
     cmo* ob = receive_cmo(fd);      cmo* ob = receive_cmo(fd);
     /* 意味的チェックが必要 */          /* We need to check semantics but yet ... */
     return new_cmo_ring_by_name(ob);      return new_cmo_ring_by_name(ob);
 }  }
   
Line 413  static void resize_mpz(mpz_ptr mpz, int size)
Line 395  static void resize_mpz(mpz_ptr mpz, int size)
     mpz->_mp_size = size;      mpz->_mp_size = size;
 }  }
   
 /** new_cmo_XXX 関数群 **/  /* functions named new_cmo_*. */
 cmo_null* new_cmo_null()  cmo_null* new_cmo_null()
 {  {
     cmo_null* m = malloc(sizeof(cmo_null));      cmo_null* m = malloc(sizeof(cmo_null));
Line 499  cmo_zz* new_cmo_zz_set_si(int i)
Line 481  cmo_zz* new_cmo_zz_set_si(int i)
     return c;      return c;
 }  }
   
   cmo_zz* new_cmo_zz_set_mpz(mpz_ptr z)
   {
       cmo_zz* c = new_cmo_zz();
       mpz_set(c->mpz, z);
       return c;
   }
   
 cmo_zz *new_cmo_zz_set_string(char *s)  cmo_zz *new_cmo_zz_set_string(char *s)
 {  {
     cmo_zz* c = new_cmo_zz_noinit();      cmo_zz* c = new_cmo_zz_noinit();
Line 636  void ox_close(ox_file_t sv)
Line 625  void ox_close(ox_file_t sv)
 {  {
     send_ox_command(sv->control, SM_control_kill);      send_ox_command(sv->control, SM_control_kill);
 #ifdef DEBUG  #ifdef DEBUG
     sleep(2); /* OpenXM server の終了を待つ. あまり意味はない. */      sleep(2);
           /* We wait thar an OpenXM server terminates. */
     fprintf(stderr, "I have closed the connection to an Open XM server.\n");      fprintf(stderr, "I have closed the connection to an Open XM server.\n");
 #endif  #endif
 }  }
   
 void ox_shutdown(ox_file_t sv)  void ox_shutdown(ox_file_t sv)
 {  {
         /* 後で SM_shutdown を用いるものに書き換える予定. */          /* We need to use SM_shutdown but yet ... */
         ox_close(sv);          ox_close(sv);
 }  }
   
Line 669  void ox_push_cmd(ox_file_t sv, int sm_code)
Line 659  void ox_push_cmd(ox_file_t sv, int sm_code)
     send_ox_command(sv->stream, sm_code);      send_ox_command(sv->stream, sm_code);
 }  }
   
 /* ox_mathcap() をコールする.  */  
 cmo_mathcap* ox_mathcap(ox_file_t sv)  cmo_mathcap* ox_mathcap(ox_file_t sv)
 {  {
     send_ox_command(sv->stream, SM_mathcap);      send_ox_command(sv->stream, SM_mathcap);
Line 706  void ox_push_cmo(ox_file_t sv, cmo *c)
Line 695  void ox_push_cmo(ox_file_t sv, cmo *c)
         send_ox_cmo(sv->stream, c);          send_ox_cmo(sv->stream, c);
 }  }
   
 /* バッファのフラッシュの振りをする. */  /* a dummy function for flushing a connection. */
 int ox_flush(ox_file_t sv)  int ox_flush(ox_file_t sv)
 {  {
         return 1;          return 1;
 }  }
   
 /* 手抜き. (後で改善しよう...) */  /* a dummy password function. */
 static char *create_otp()  static char *create_otp()
 {  {
     static char otp[] = "otpasswd";      static char otp[] = "otpasswd";
     return otp;      return otp;
 }  }
   
 /* OneTimePassword の処理 */  /* proceeding an one time password. */
 static int login_with_otp(int fd, char* passwd)  static int login_with_otp(int fd, char* passwd)
 {  {
     int len   = strlen(passwd)+1;      int len   = strlen(passwd)+1;
Line 741  static int login_with_otp(int fd, char* passwd)
Line 730  static int login_with_otp(int fd, char* passwd)
     return ret;      return ret;
 }  }
   
 static int exists_ox(char *dir, char *prog)  /* The environment variable OpenXM_HOME must be defined. */
   static char *concat_openxm_home_bin(char *s)
 {  {
     char *path = alloca(strlen(dir)+strlen(prog)+6);      char *path;
     sprintf(path, "%s/%s", dir, prog);      char *base;
     return access(path, X_OK|R_OK);  
       /* if s includes '/' then it is not concaticated. */
           if (strchr(s, '/') != NULL) {
                   return s;
           }
   
           base = getenv("OpenXM_HOME");
           path = malloc(strlen(base)+5+strlen(s));
           sprintf(path, "%s/bin/%s", base, s);
           return path;
 }  }
   
 static char *search_ox(char *prog)  /* example: which("xterm", getenv("PATH")); */
   static char *which(char *prog, char *path_env)
 {  {
     char *env = getenv("OpenXM_HOME");          char *tok;
     char *dir;          char *path;
     if (env != NULL) {          char delim[] = ":";
         dir = malloc(strlen(env)+5);          char *e = alloca(strlen(path_env)+1);
         sprintf(dir, "%s/bin", env);          strcpy(e, path_env);
         if (exists_ox(dir, prog) == 0) {          tok = strtok(e, delim);
             return dir;          while (tok != NULL) {
         }                  char *path = malloc(strlen(tok)+strlen(prog)+2);
         free(dir);                  sprintf(path, "%s/%s", tok, prog);
     }                  if (access(path, X_OK&R_OK) == 0) {
     dir = "/usr/local/OpenXM/bin";                          return path;
     if (exists_ox(dir, prog) == 0) {                  }
         return dir;                  free(path);
     }                  tok = strtok(NULL, delim);
     dir = ".";          }
     if (exists_ox(dir, prog) == 0) {          return NULL;
         return dir;  
     }  
     return NULL;  
 }  }
   
 static int mysocketAccept2(int fd, char *pass)  static int mysocketAccept2(int fd, char *pass)
Line 782  static int mysocketAccept2(int fd, char *pass)
Line 779  static int mysocketAccept2(int fd, char *pass)
     return -1;      return -1;
 }  }
   
   /* if it is not 0, then we use oxlog to execute ox. */
   static int flag_ox_start_with_oxlog = 1;
   
 /*  /*
    (-reverse 版の ox_start)     (-reverse 版の ox_start)
    ox_start は クライアントが呼び出すための関数である.     ox_start は クライアントが呼び出すための関数である.
Line 793  static int mysocketAccept2(int fd, char *pass)
Line 793  static int mysocketAccept2(int fd, char *pass)
   
 ox_file_t ox_start(char* host, char* ctl_prog, char* dat_prog)  ox_file_t ox_start(char* host, char* ctl_prog, char* dat_prog)
 {  {
       ox_file_t sv = NULL;
     char *pass;      char *pass;
     char ctl[16], dat[16];      char ctl[128], dat[128];
     short portControl = 0; /* short であることに注意 */      short portControl = 0;  /* short! */
     short portStream  = 0;      short portStream  = 0;
     ox_file_t sv = NULL;          char *oxlog;
     char *dir;  
         char *oxlog = "/home/ohara/OpenXM/bin/oxlog";  
   
     if ((dir = search_ox(ctl_prog)) == NULL) {          /* not overwrite */
         fprintf(stderr, "client:: %s not found.\n", ctl_prog);          setenv("OpenXM_HOME", "/usr/local/OpenXM", 0);
         return NULL;  
     }          oxlog    = concat_openxm_home_bin("oxlog");
           ctl_prog = concat_openxm_home_bin(ctl_prog);
           dat_prog = concat_openxm_home_bin(dat_prog);
   
     sv = malloc(sizeof(__ox_file_struct));      sv = malloc(sizeof(__ox_file_struct));
     sv->control = mysocketListen(host, &portControl);      sv->control = mysocketListen(host, &portControl);
     sv->stream  = mysocketListen(host, &portStream);      sv->stream  = mysocketListen(host, &portStream);
Line 814  ox_file_t ox_start(char* host, char* ctl_prog, char* d
Line 816  ox_file_t ox_start(char* host, char* ctl_prog, char* d
     pass = create_otp();      pass = create_otp();
   
     if (fork() == 0) {      if (fork() == 0) {
         dup2(2, 1);                  if (flag_ox_start_with_oxlog) {
         dup2(open(DEFAULT_LOGFILE, O_RDWR|O_CREAT|O_TRUNC, 0644), 2);                          execl(oxlog, oxlog, "xterm", "-icon", "-e", ctl_prog,
         chdir(dir);                                    "-reverse", "-ox", dat_prog,
         execl(oxlog, oxlog, "/usr/X11R6/bin/xterm", "-icon", "-e",                                    "-data", dat, "-control", ctl, "-pass", pass,
                           ctl_prog, "-reverse", "-ox", dat_prog,                                    "-host", host, NULL);
               "-data", dat, "-control", ctl, "-pass", pass,                  }else {
               "-host", host, NULL);                          dup2(2, 1);
                           dup2(open(tempnam("/tmp", "ox."), O_RDWR|O_CREAT|O_TRUNC, 0644),  2);
                           execl(ctl_prog, ctl_prog, "-reverse", "-ox", dat_prog,
                                     "-data", dat, "-control", ctl, "-pass", pass,
                                     "-host", host, NULL);
                   }
                   exit(1);
     }      }
   
     if ((sv->control = mysocketAccept2(sv->control, pass)) == -1) {      if ((sv->control = mysocketAccept2(sv->control, pass)) == -1) {
         close(sv->stream);          close(sv->stream);
         return NULL;          return NULL;
     }      }
     /* 10マイクロ秒, 時間稼ぎする. */      /* waiting 10 micro second. */
     usleep(10);      usleep(10);
     if((sv->stream  = mysocketAccept2(sv->stream, pass)) == -1) {      if((sv->stream  = mysocketAccept2(sv->stream, pass)) == -1) {
         return NULL;          return NULL;
Line 835  ox_file_t ox_start(char* host, char* ctl_prog, char* d
Line 843  ox_file_t ox_start(char* host, char* ctl_prog, char* d
     return sv;      return sv;
 }  }
   
   /* ssh -f host oxlog xterm -e ox -ox ox_asir ... */
   int ssh_ox_server(char *host, char *ctl_prog, char *dat_prog, short portControl, short portStream)
   {
           char *oxlog;
           char *ssh;
           oxlog    = concat_openxm_home_bin("oxlog");
           ctl_prog = concat_openxm_home_bin(ctl_prog);
           dat_prog = concat_openxm_home_bin(dat_prog);
   
           ssh = which("ssh", getenv(PATH));
   
           if (fork() == 0) {
                   execl(ssh, ssh, "-f", host, oxlog, "xterm", "-icon",
                             "-e", ctl_prog, "-insecure", "-ox", dat_prog,
                             "-data", portStream, "-control", portControl, "-host", host, NULL);
                   exit(1);
           }
   }
   
 /*  /*
    (-insecure 版の ox_start)  まだ、中身はありません。     (-insecure 版の ox_start)  まだ、中身はありません。
    ox_start_insecure_nonreverse は クライアントが呼び出すための関数である.     ox_start_insecure_nonreverse は クライアントが呼び出すための関数である.
Line 853  ox_file_t ox_start_insecure_nonreverse(char* host, sho
Line 880  ox_file_t ox_start_insecure_nonreverse(char* host, sho
     /* ox は insecure のとき byte order の決定が正しくできないようだ... */      /* ox は insecure のとき byte order の決定が正しくできないようだ... */
     decideByteOrderClient(sv->control, 0);      decideByteOrderClient(sv->control, 0);
 #endif  #endif
     /* 10マイクロ秒, 時間稼ぎする. */      /* wainting 10 micro second. */
     usleep(10);      usleep(10);
     sv->stream  = mysocketOpen(host, portStream);      sv->stream  = mysocketOpen(host, portStream);
     decideByteOrderClient(sv->stream, 0);      decideByteOrderClient(sv->stream, 0);
     return sv;      return sv;
 }  }
   
   ox_file_t ox_start_insecure_nonreverse2(char* host, char *ctl_prog, char *dat_prog)
   {
           short portControl= 1200;  /* 自動生成させよう... */
           short portStream = 1300;
   
           ssh_ox_server(host, ctl_prog, dat_prog, portControl, portStream);
           return ox_start_insecure_nonreverse(host, portControl, portStream);
   }
   
 void ox_reset(ox_file_t sv)  void ox_reset(ox_file_t sv)
 {  {
     send_ox_command(sv->control, SM_control_reset_connection);      send_ox_command(sv->control, SM_control_reset_connection);
Line 877  void ox_reset(ox_file_t sv)
Line 913  void ox_reset(ox_file_t sv)
 #endif  #endif
 }  }
   
 /* 以下は bconv.c で必要とする関数群である. */  /* the following functions are needed by bconv.c */
   
 /* cmolen 関数は cmo の(送信時の)バイト長を返す. */  /* cmolen 関数は cmo の(送信時の)バイト長を返す. */
 /* cmolen_XXX 関数は cmo_XXX の tag を除いたバイト長を返す. */  /* cmolen_XXX 関数は cmo_XXX の tag を除いたバイト長を返す. */
Line 931  static int cmolen_cmo_distributed_polynomial(cmo_distr
Line 967  static int cmolen_cmo_distributed_polynomial(cmo_distr
     return cmolen_cmo_list((cmo_list *)c) + cmolen_cmo(c->ringdef);      return cmolen_cmo_list((cmo_list *)c) + cmolen_cmo(c->ringdef);
 }  }
   
 /* CMO がバイトエンコードされた場合のバイト列の長さを求める */  /* calculating the length of the byte stream of given CMO.  */
 int cmolen_cmo(cmo* c)  int cmolen_cmo(cmo* c)
 {  {
     int size = sizeof(int);      int size = sizeof(int);
Line 1042  static int dump_cmo_distributed_polynomial(cmo_distrib
Line 1078  static int dump_cmo_distributed_polynomial(cmo_distrib
     }      }
 }  }
   
 /* タグを書き出してから、各関数を呼び出す */  /* after its tag is sent, we invoke each functions. */
 int dump_cmo(cmo* m)  int dump_cmo(cmo* m)
 {  {
     dump_integer(m->tag);      dump_integer(m->tag);
Line 1141  int send_ox_cmo(int fd, cmo* m)
Line 1177  int send_ox_cmo(int fd, cmo* m)
     send_cmo(fd, m);      send_cmo(fd, m);
 }  }
   
 /* send_cmo_xxx 関数群 */  /* send_cmo_* functions */
 static int send_cmo_null(int fd, cmo_null* c)  static int send_cmo_null(int fd, cmo_null* c)
 {  {
     return 0;      return 0;
Line 1219  static int send_cmo_error2(int fd, cmo_error2* c)
Line 1255  static int send_cmo_error2(int fd, cmo_error2* c)
     return 0;      return 0;
 }  }
   
 /* CMOを送る.  OX_tag は送信済*/  /* sending a CMO.  (Remarks: OX_tag is already sent.) */
 int send_cmo(int fd, cmo* c)  int send_cmo(int fd, cmo* c)
 {  {
     int tag = c->tag;      int tag = c->tag;
Line 1231  int send_cmo(int fd, cmo* c)
Line 1267  int send_cmo(int fd, cmo* c)
     case CMO_NULL:      case CMO_NULL:
     case CMO_ZERO:      case CMO_ZERO:
     case CMO_DMS_GENERIC:      case CMO_DMS_GENERIC:
         send_cmo_null(fd, c);  /* 空の関数 */          send_cmo_null(fd, c);  /* empty function. */
         break;          break;
     case CMO_INT32:      case CMO_INT32:
         send_cmo_int32(fd, (cmo_int32 *)c);          send_cmo_int32(fd, (cmo_int32 *)c);
Line 1303  static cmo_list* make_list_of_id(int ver, char* ver_s,
Line 1339  static cmo_list* make_list_of_id(int ver, char* ver_s,
     cmo_list *cap;      cmo_list *cap;
     char buff[512];      char buff[512];
   
     setgetc(mygetc);  
     sprintf(buff, ID_TEMP, ver, sysname, ver_s, getenv("HOSTTYPE"));      sprintf(buff, ID_TEMP, ver, sysname, ver_s, getenv("HOSTTYPE"));
     setmode_mygetc(buff, 512);      init_parser(buff);
     cap = (cmo_list *)parse();      cap = (cmo_list *)parse();
     resetgetc();  
   
     return cap;      return cap;
 }  }
Line 1437  char *new_string_set_cmo(cmo *m)
Line 1471  char *new_string_set_cmo(cmo *m)
         symp = lookup_by_tag(m->tag);          symp = lookup_by_tag(m->tag);
         fprintf(stderr, "I do not know how to convert %s to a string.\n", symp->key);          fprintf(stderr, "I do not know how to convert %s to a string.\n", symp->key);
 #endif  #endif
         /* まだ実装していません. */          /* yet not implemented. */
         return NULL;          return NULL;
     }      }
 }  }
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.8
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>