=================================================================== RCS file: /home/cvs/OpenXM/src/ox_math/Attic/ox.c,v retrieving revision 1.1.1.1 retrieving revision 1.7 diff -u -p -r1.1.1.1 -r1.7 --- OpenXM/src/ox_math/Attic/ox.c 1999/10/29 08:06:41 1.1.1.1 +++ OpenXM/src/ox_math/Attic/ox.c 1999/11/04 06:21:58 1.7 @@ -1,6 +1,5 @@ /* -*- mode: C; coding: euc-japan -*- */ -/* $OpenXM$ */ -/* $Id: ox.c,v 1.1.1.1 1999/10/29 08:06:41 ohara Exp $ */ +/* $OpenXM: OpenXM/src/ox_math/ox.c,v 1.6 1999/11/04 03:05:50 ohara Exp $ */ /* 関数の名前付け規約(その2): @@ -43,49 +42,63 @@ static int cmolen_cmo_mathcap(cmo_mathcap* c) static int cmolen_cmo_null(cmo_null* c); static int cmolen_cmo_string(cmo_string* c); static int cmolen_cmo_zz(cmo_zz* c); +static int cmolen_cmo_monomial32(cmo_monomial32* c); -static char* dump_cmo_int32(char* array, cmo_int32* m); -static char* dump_cmo_list(char* array, cmo_list* m); -static char* dump_cmo_mathcap(char* array, cmo_mathcap* m); -static char* dump_cmo_null(char* array, cmo_null* m); -static char* dump_cmo_string(char* array, cmo_string* m); -static char* dump_cmo_zz(char* array, cmo_zz* c); -static char* dump_integer(char* array, int x); -static char* dump_mpz(char* array, mpz_ptr mpz); +static int dump_cmo_int32(cmo_int32* m); +static int dump_cmo_list(cmo_list* m); +static int dump_cmo_mathcap(cmo_mathcap* m); +static int dump_cmo_null(cmo_null* m); +static int dump_cmo_string(cmo_string* m); +static int dump_cmo_monomial32(cmo_monomial32* c); +static int dump_cmo_zz(cmo_zz* c); +static int dump_string(char *s, int len); +static int dump_integer(int x); +static int dump_mpz(mpz_ptr mpz); static int funcs(int cmo_type); -static int read_password(int fd, char* passwd); -static cmo_error* receive_cmo_error(int fd); -static cmo_int32* receive_cmo_int32(int fd); -static cmo_list* receive_cmo_list(int fd); -static cmo_mathcap* receive_cmo_mathcap(int fd); +static int login_with_otp(int fd, char* passwd); +static char *create_otp(); + +/* CMO_xxx の値順にならべること(デバッグのため) */ static cmo_null* receive_cmo_null(int fd); +static cmo_int32* receive_cmo_int32(int fd); static cmo_string* receive_cmo_string(int fd); +static cmo_mathcap* receive_cmo_mathcap(int fd); +static cmo_list* receive_cmo_list(int fd); +static cmo_monomial32* receive_cmo_monomial32(int fd); static cmo_zz* receive_cmo_zz(int fd); +static cmo_zero* receive_cmo_zero(int fd); +static cmo_dms_generic* receive_cmo_dms_generic(int fd); +static cmo_ring_by_name* receive_cmo_ring_by_name(int fd); +static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(int fd); + +static cmo_error2* receive_cmo_error2(int fd); static void receive_mpz(int fd, mpz_ptr mpz); -static int send_cmo_error(int fd, cmo_error* c); -static int send_cmo_int32(int fd, cmo_int32* m); -static int send_cmo_list(int fd, cmo_list* c); -static int send_cmo_mathcap(int fd, cmo_mathcap* c); static int send_cmo_null(int fd, cmo_null* c); +static int send_cmo_int32(int fd, cmo_int32* m); static int send_cmo_string(int fd, cmo_string* m); +static int send_cmo_mathcap(int fd, cmo_mathcap* c); +static int send_cmo_list(int fd, cmo_list* c); +static int send_cmo_monomial32(int fd, cmo_monomial32* c); static int send_cmo_zz(int fd, cmo_zz* c); +static int send_cmo_error2(int fd, cmo_error2* c); static int send_mpz(int fd, mpz_ptr mpz); +static int send_cmo_distributed_polynomial(int fd, cmo_distributed_polynomial* c); /* エラーハンドリングのため */ static int current_received_serial = 0; /* エラーを起こしたときはサーバは次のようにすればよい. */ -cmo_error* gen_error_object(int err_code) +cmo_error2* gen_error_object(int err_code) { cmo_list* li = new_cmo_list(); append_cmo_list(li, (cmo *)new_cmo_int32(current_received_serial)); append_cmo_list(li, (cmo *)new_cmo_int32(err_code)); /* 他の情報を加えるならココ */ - return new_cmo_error(li); + return new_cmo_error2((cmo *)li); } /* add at Mon Sep 7 15:51:28 JST 1998 */ @@ -140,6 +153,11 @@ cell* new_cell(cmo* newcmo) return h; } +cell* next_cell(cell* this) +{ + return this->next; +} + static cell* *tailp(cmo_list* this) { cell **cp = &this->head; while (*cp != NULL) { @@ -163,10 +181,9 @@ int append_cmo_list(cmo_list* this, cmo* newcmo) } /** receive_cmo_XXX 関数群 **/ -static cmo_error* receive_cmo_error(int fd) +static cmo_null* receive_cmo_null(int fd) { - cmo_list* li = (cmo_list *)receive_cmo(fd); - return new_cmo_error(li); + return new_cmo_null(); } static cmo_int32* receive_cmo_int32(int fd) @@ -175,49 +192,150 @@ static cmo_int32* receive_cmo_int32(int fd) return new_cmo_int32(i); } +static cmo_string* receive_cmo_string(int fd) +{ + int len = receive_int32(fd); + char* s = malloc(len+1); + memset(s, '\0', len+1); + if (len > 0) { + read(fd, s, len); + } + return new_cmo_string(s); +} + +static cmo_mathcap* receive_cmo_mathcap(int fd) +{ + cmo* ob = receive_cmo(fd); + return new_cmo_mathcap(ob); +} + static cmo_list* receive_cmo_list(int fd) { - cmo* newcmo; + cmo* ob; cmo_list* c = new_cmo_list(); int len = receive_int32(fd); while (len>0) { - newcmo = receive_cmo(fd); - append_cmo_list(c, newcmo); + ob = receive_cmo(fd); + append_cmo_list(c, ob); len--; } return c; } -static cmo_mathcap* receive_cmo_mathcap(int fd) +static cmo_monomial32* receive_cmo_monomial32(int fd) { - cmo_list* li = (cmo_list *)receive_cmo(fd); - return new_cmo_mathcap(li); + int i; + int len = receive_int32(fd); + cmo_monomial32* c = new_cmo_monomial32(len); + + for(i=0; iexps[i] = receive_int32(fd); + } + c->coef = receive_cmo(fd); + return c; } -static cmo_null* receive_cmo_null(int fd) +static cmo_zz* receive_cmo_zz(int fd) { - return new_cmo_null(); + cmo_zz* c = new_cmo_zz(); + receive_mpz(fd, c->mpz); + return c; } -static cmo_string* receive_cmo_string(int fd) +static cmo_zero* receive_cmo_zero(int fd) { + return new_cmo_zero(); +} + +static cmo_dms_generic* receive_cmo_dms_generic(int fd) +{ + return new_cmo_dms_generic(); +} + +static cmo_ring_by_name* receive_cmo_ring_by_name(int fd) +{ + cmo* ob = receive_cmo(fd); + /* 意味的チェックが必要 */ + return new_cmo_ring_by_name(ob); +} + +static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(int fd) +{ + cmo* ob; + cmo_distributed_polynomial* c = new_cmo_distributed_polynomial(); int len = receive_int32(fd); - char* s = malloc(len+1); - memset(s, '\0', len+1); - if (len > 0) { - read(fd, s, len); + c->ringdef = receive_cmo(fd); + + while (len>0) { + ob = receive_cmo(fd); + append_cmo_list(c, ob); + len--; } - return new_cmo_string(s); + return c; } -static cmo_zz* receive_cmo_zz(int fd) +static cmo_error2* receive_cmo_error2(int fd) { - cmo_zz* c = new_cmo_zz(); - receive_mpz(fd, c->mpz); - return c; + cmo* ob = receive_cmo(fd); + return new_cmo_error2(ob); } +/* receive_ox_tag() == OX_DATA の後に呼び出される */ +/* 関数ポインタを使った方がきれいに書けるような気がする. */ +/* if (foo[tag] != NULL) foo[tag](fd); とか */ + +cmo* receive_cmo(int fd) +{ + cmo* m; + int tag; + tag = receive_int32(fd); + + switch(tag) { + case CMO_NULL: + m = receive_cmo_null(fd); + break; + case CMO_INT32: + m = (cmo *)receive_cmo_int32(fd); + break; + case CMO_STRING: + m = (cmo *)receive_cmo_string(fd); + break; + case CMO_MATHCAP: + m = (cmo *)receive_cmo_mathcap(fd); + break; + case CMO_LIST: + m = (cmo *)receive_cmo_list(fd); + break; + case CMO_MONOMIAL32: + m = (cmo *)receive_cmo_monomial32(fd); + break; + case CMO_ZZ: + m = (cmo *)receive_cmo_zz(fd); + break; + case CMO_ZERO: + m = (cmo *)receive_cmo_zero(fd); + break; + case CMO_DMS_GENERIC: + m = (cmo *)receive_cmo_dms_generic(fd); + break; + case CMO_RING_BY_NAME: + m = (cmo *)receive_cmo_ring_by_name(fd); + break; + case CMO_DISTRIBUTED_POLYNOMIAL: + m = (cmo *)receive_cmo_distributed_polynomial(fd); + break; + case CMO_ERROR2: + m = (cmo *)receive_cmo_error2(fd); + break; + case CMO_DATUM: + case CMO_QQ: + default: + fprintf(stderr, "unknown cmo-type: tag = (%d)\n", m->tag); + } + return m; +} + static void receive_mpz(int fd, mpz_ptr mpz) { int i; @@ -237,12 +355,11 @@ void resize_mpz(mpz_ptr mpz, int size) } /** new_cmo_XXX 関数群 **/ -cmo_error* new_cmo_error(cmo_list* li) +cmo_null* new_cmo_null() { - cmo_error* c = malloc(sizeof(cmo_error)); - c->tag = CMO_ERROR2; - c->li = li; - return c; + cmo_null* m = malloc(sizeof(cmo_null)); + m->tag = CMO_NULL; + return m; } cmo_int32* new_cmo_int32(int i) @@ -254,38 +371,53 @@ cmo_int32* new_cmo_int32(int i) return c; } -cmo_list* new_cmo_list() +cmo_string* new_cmo_string(char* s) { - cmo_list* c = malloc(sizeof(cmo_list)); - c->tag = CMO_LIST; - c->length = 0; - c->head = NULL; + cmo_string* c = malloc(sizeof(cmo_string)); + c->tag = CMO_STRING; + if (s != NULL) { + c->s = malloc(strlen(s)+1); + strcpy(c->s, s); + }else { + c->s = NULL; + } return c; } -cmo_mathcap* new_cmo_mathcap(cmo_list* li) +cmo_mathcap* new_cmo_mathcap(cmo* ob) { cmo_mathcap* c = malloc(sizeof(cmo_mathcap)); c->tag = CMO_MATHCAP; - c->li = li; + c->ob = ob; return c; } -cmo_null* new_cmo_null() +cmo_list* new_cmo_list() { - cmo* m = malloc(sizeof(cmo)); - m->tag = CMO_NULL; - return m; + cmo_list* c = malloc(sizeof(cmo_list)); + c->tag = CMO_LIST; + c->length = 0; + c->head = NULL; + return c; } -cmo_string* new_cmo_string(char* s) +cmo_monomial32* new_cmo_monomial32() { - cmo_string* c = malloc(sizeof(cmo_string)); - c->tag = CMO_STRING; - c->s = s; + cmo_monomial32* c = malloc(sizeof(cmo_monomial32)); + c->tag = CMO_MONOMIAL32; return c; } +cmo_monomial32* new_cmo_monomial32_size(int size) +{ + cmo_monomial32* c = new_cmo_monomial32(); + if (size>0) { + c->length = size; + c->exps = malloc(sizeof(int)*size); + } + return c; +} + cmo_zz* new_cmo_zz() { cmo_zz* c = malloc(sizeof(cmo_zz)); @@ -308,6 +440,13 @@ cmo_zz* new_cmo_zz_set_si(int i) return c; } +cmo_zz *new_cmo_zz_set_string(char *s) +{ + cmo_zz* c = new_cmo_zz_noinit(); + mpz_init_set_str(c->mpz, s, 10); + return c; +} + cmo_zz* new_cmo_zz_size(int size) { cmo_zz* c = new_cmo_zz(); @@ -315,48 +454,54 @@ cmo_zz* new_cmo_zz_size(int size) return c; } -/* receive_ox_tag() == OX_DATA の後に呼び出される */ -/* 関数ポインタを使った方がきれいに書けるような気がする. */ -/* if (foo[tag] != NULL) foo[tag](fd); とか */ - -cmo* receive_cmo(int fd) +cmo_zero* new_cmo_zero() { - cmo* m; - int tag; - tag = receive_int32(fd); + cmo_zero* m = malloc(sizeof(cmo_zero)); + m->tag = CMO_ZERO; + return m; +} - switch(tag) { - case CMO_NULL: - m = receive_cmo_null(fd); - break; - case CMO_INT32: - m = (cmo *)receive_cmo_int32(fd); - break; - case CMO_STRING: - m = (cmo *)receive_cmo_string(fd); - break; - case CMO_ZZ: - m = (cmo *)receive_cmo_zz(fd); - break; - case CMO_LIST: - m = (cmo *)receive_cmo_list(fd); - break; - case CMO_MATHCAP: - m = (cmo *)receive_cmo_mathcap(fd); - break; - case CMO_ERROR2: - m = (cmo *)receive_cmo_error(fd); - break; - case CMO_DATUM: - case CMO_QQ: - case CMO_ZERO: - case CMO_DMS: - default: - fprintf(stderr, "unknown cmo-type: tag = (%d)\n", m->tag); - } +cmo_dms_generic* new_cmo_dms_generic() +{ + cmo_dms_generic* m = malloc(sizeof(cmo_dms_generic)); + m->tag = CMO_DMS_GENERIC; return m; } +cmo_ring_by_name* new_cmo_ring_by_name(cmo* ob) +{ + cmo_ring_by_name* c = malloc(sizeof(cmo_ring_by_name)); + c->tag = CMO_RING_BY_NAME; + c->ob = ob; + return c; +} + +cmo_indeterminate* new_cmo_indeterminate(cmo* ob) +{ + cmo_indeterminate* c = malloc(sizeof(cmo_indeterminate)); + c->tag = CMO_INDETERMINATE; + c->ob = ob; + return c; +} + +cmo_distributed_polynomial* new_cmo_distributed_polynomial() +{ + cmo_distributed_polynomial* c = malloc(sizeof(cmo_distributed_polynomial)); + c->tag = CMO_DISTRIBUTED_POLYNOMIAL; + c->length = 0; + c->head = NULL; + c->ringdef = NULL; + return c; +} + +cmo_error2* new_cmo_error2(cmo* ob) +{ + cmo_error2* c = malloc(sizeof(cmo_error2)); + c->tag = CMO_ERROR2; + c->ob = ob; + return c; +} + void send_ox_command(int fd, int sm_command) { send_ox_tag(fd, OX_COMMAND); @@ -407,7 +552,7 @@ int print_cmo_list(cmo_list* li) int print_cmo_mathcap(cmo_mathcap* c) { fprintf(stderr, "\n"); - print_cmo((cmo *)c->li); + print_cmo(c->ob); } int print_cmo_string(cmo_string* c) @@ -415,19 +560,6 @@ int print_cmo_string(cmo_string* c) fprintf(stderr, "cmo_string = (%s)\n", c->s); } -/* ox_start() から呼び出す */ -static int read_password(int fd, char* passwd) -{ - char buff[1024]; - int n; - if ((n = read(fd, buff, 1024)) != strlen(passwd)) { - fprintf(stderr, "Socket#%d: Login incorrect.\n", fd); - fprintf(stderr, "password = (%s), received = (%s).\n", passwd, buff); - fprintf(stderr, " = (%d), received = (%d).\n", strlen(passwd), n); - } - fflush(stderr); -} - void ox_close(ox_file_t sv) { send_ox_command(sv->control, SM_control_kill); @@ -472,7 +604,29 @@ cmo* ox_pop_cmo(ox_file_t sv, int fd) return receive_cmo(fd); } +/* 手抜き. (後で改善しよう...) */ +static char *create_otp() +{ + static char otp[] = "otpasswd"; + return otp; +} + +/* OneTimePassword の処理 */ +static int login_with_otp(int fd, char* passwd) +{ + char buff[1024]; + int n = read(fd, buff, 1024); + int len = strlen(passwd)+1; + if (n != len) { + fprintf(stderr, "Socket#%d: Login incorrect.\n", fd); + fprintf(stderr, "password = (%s), length = (%d).\n", passwd, len); + fprintf(stderr, "received = (%d), length = (%d).\n", buff, n); + fflush(stderr); + } +} + /* + (-reverse 版の ox_start) ox_start は クライアントが呼び出すための関数である. サーバでは使われない. prog1 は コントロールサーバであり, -ox, -reverse, -data, -control, -pass, -host @@ -482,7 +636,7 @@ cmo* ox_pop_cmo(ox_file_t sv, int fd) ox_file_t ox_start(char* host, char* prog1, char* prog2) { - static char pass[] = "passwd"; + char *pass = create_otp(); char ctl[16], dat[16]; short portControl = 0; /* short であることに注意 */ short portStream = 0; @@ -502,16 +656,37 @@ ox_file_t ox_start(char* host, char* prog1, char* prog } sv->control = mysocketAccept(sv->control); - read_password(sv->control, pass); - decideByteOrder(sv->control, sv->control, 0); + login_with_otp(sv->control, pass); + decideByteOrderClient(sv->control, 0); + /* 10マイクロ秒, 時間稼ぎする. */ usleep(10); sv->stream = mysocketAccept(sv->stream); - read_password(sv->stream, pass); - decideByteOrder(sv->stream, sv->stream, 0); + login_with_otp(sv->stream, pass); + decideByteOrderClient(sv->stream, 0); return sv; } +/* + (-insecure 版の ox_start) まだ、中身はありません。 + ox_start_insecure_nonreverse は クライアントが呼び出すための関数である. + 接続時には, sv->control を先にオープンする. + 既定値: + portControl = 1200 + portStream = 1300 +*/ + +ox_file_t ox_start_insecure_nonreverse(char* host, short portControl, short portStream) +{ + ox_file_t sv = malloc(sizeof(__ox_file_struct)); + + sv->control = mysocketOpen(host, portControl); + /* 10マイクロ秒, 時間稼ぎする. */ + usleep(10); + sv->stream = mysocketOpen(host, portStream); + return sv; +} + void ox_reset(ox_file_t sv) { send_ox_command(sv->control, SM_control_reset_connection); @@ -529,15 +704,31 @@ void ox_reset(ox_file_t sv) #endif } -/* 以下は parse.c で必要とする関数たち */ -/* cmolen 関数は cmo の(送信時の)バイト長を返す */ -/* cmolen_XXX 関数は tag を除いたバイト長を返す */ +/* 以下は bconv.c で必要とする関数群である. */ +/* cmolen 関数は cmo の(送信時の)バイト長を返す. */ +/* cmolen_XXX 関数は cmo_XXX の tag を除いたバイト長を返す. */ + +static int cmolen_cmo_null(cmo_null* c) +{ + return 0; +} + static int cmolen_cmo_int32(cmo_int32* c) { return sizeof(int); } +static int cmolen_cmo_string(cmo_string* c) +{ + return sizeof(int)+strlen(c->s); +} + +static int cmolen_cmo_mathcap(cmo_mathcap* c) +{ + return cmolen_cmo(c->ob); +} + static int cmolen_cmo_list(cmo_list* c) { int size = sizeof(c->head); @@ -550,27 +741,23 @@ static int cmolen_cmo_list(cmo_list* c) return size; } -static int cmolen_cmo_mathcap(cmo_mathcap* c) +static int cmolen_cmo_monomial32(cmo_monomial32* c) { - return cmolen_cmo((cmo *)c->li); + int len = (c->length + 1)*sizeof(int); + return len + cmolen_cmo(c->coef); } -static int cmolen_cmo_null(cmo_null* c) -{ - return 0; -} - -static int cmolen_cmo_string(cmo_string* c) -{ - return sizeof(int)+strlen(c->s); -} - static int cmolen_cmo_zz(cmo_zz* c) { int len = abs(c->mpz->_mp_size); return sizeof(len) + len*sizeof(int); } +static int cmolen_cmo_distributed_polynomial(cmo_distributed_polynomial* c) +{ + return cmolen_cmo_list((cmo_list *)c) + cmolen_cmo(c->ringdef); +} + /* CMO がバイトエンコードされた場合のバイト列の長さを求める */ int cmolen_cmo(cmo* c) { @@ -578,6 +765,8 @@ int cmolen_cmo(cmo* c) switch(c->tag) { case CMO_NULL: + case CMO_ZERO: + case CMO_DMS_GENERIC: size += cmolen_cmo_null(c); break; case CMO_INT32: @@ -586,102 +775,173 @@ int cmolen_cmo(cmo* c) case CMO_STRING: size += cmolen_cmo_string((cmo_string *)c); break; + case CMO_MATHCAP: + case CMO_RING_BY_NAME: + case CMO_ERROR2: + size += cmolen_cmo_mathcap((cmo_mathcap *)c); + break; case CMO_LIST: size += cmolen_cmo_list((cmo_list *)c); break; + case CMO_MONOMIAL32: + size += cmolen_cmo_monomial32((cmo_monomial32 *)c); + break; case CMO_ZZ: size += cmolen_cmo_zz((cmo_zz *)c); break; - case CMO_MATHCAP: - size += cmolen_cmo_mathcap((cmo_mathcap *)c); - break; + case CMO_DISTRIBUTED_POLYNOMIAL: + size += cmolen_cmo_distributed_polynomial((cmo_distributed_polynomial *)c); + break; default: } return size; } -static char* dump_cmo_int32(char* array, cmo_int32* m) +static int d_ptr; +static char *d_buf; + +int init_dump_buffer(char *s) { - return dump_integer(array, m->i); + d_buf = s; + d_ptr = 0; } -static char* dump_cmo_list(char* array, cmo_list* m) +static int dump_cmo_null(cmo_null* m) { + return 0; +} + +static int dump_cmo_int32(cmo_int32* m) +{ + dump_integer(m->i); +} + +static int dump_cmo_string(cmo_string* m) +{ + int len = strlen(m->s); + dump_integer(len); + dump_string(m->s, len); +} + +static int dump_cmo_mathcap(cmo_mathcap* c) +{ + dump_cmo(c->ob); +} + +static int dump_cmo_list(cmo_list* m) +{ cell* cp = m->head; int len = length_cmo_list(m); - array = dump_integer(array, len); + dump_integer(len); while(cp != NULL) { - array = dump_cmo(array, cp->cmo); + dump_cmo(cp->cmo); cp = cp->next; } - return array; } -static char* dump_cmo_mathcap(char* array, cmo_mathcap* c) +static int dump_cmo_monomial32(cmo_monomial32* c) { - return dump_cmo(array, (cmo *)c->li); + int i; + int length = c->length; + dump_integer(c->length); + for(i=0; iexps[i]); + } + dump_cmo(c->coef); } -static char* dump_cmo_null(char* array, cmo_null* m) +static int dump_cmo_zz(cmo_zz* c) { - return array; + dump_mpz(c->mpz); } -static char* dump_cmo_string(char* array, cmo_string* m) +static int dump_cmo_distributed_polynomial(cmo_distributed_polynomial* m) { - int len = strlen(m->s); - array = dump_integer(array, len); - memcpy(array, m->s, len); - return array + len; + cell* cp = m->head; + int len = length_cmo_list((cmo_list *)m); + dump_integer(len); + dump_cmo(m->ringdef); + while(cp != NULL) { + dump_cmo(cp->cmo); + cp = cp->next; + } } -static char* dump_cmo_zz(char* array, cmo_zz* c) -{ - return dump_mpz(array, c->mpz); -} - /* タグを書き出してから、各関数を呼び出す */ -char* dump_cmo(char* array, cmo* m) +int dump_cmo(cmo* m) { - array = dump_integer(array, m->tag); + dump_integer(m->tag); switch(m->tag) { case CMO_NULL: - return dump_cmo_null(array, m); + case CMO_ZERO: + case CMO_DMS_GENERIC: + dump_cmo_null(m); + break; case CMO_INT32: - return dump_cmo_int32(array, (cmo_int32 *)m); + dump_cmo_int32((cmo_int32 *)m); + break; case CMO_STRING: - return dump_cmo_string(array, (cmo_string *)m); + dump_cmo_string((cmo_string *)m); + break; + case CMO_MATHCAP: + case CMO_RING_BY_NAME: + case CMO_ERROR2: + dump_cmo_mathcap((cmo_mathcap *)m); + break; case CMO_LIST: - return dump_cmo_list(array, (cmo_list *)m); + dump_cmo_list((cmo_list *)m); + break; + case CMO_MONOMIAL32: + dump_cmo_monomial32((cmo_monomial32 *)m); + break; case CMO_ZZ: - return dump_cmo_zz(array, (cmo_zz *)m); - case CMO_MATHCAP: - return dump_cmo_mathcap(array, (cmo_mathcap *)m); + dump_cmo_zz((cmo_zz *)m); + break; + case CMO_DISTRIBUTED_POLYNOMIAL: + dump_cmo_distributed_polynomial((cmo_distributed_polynomial *)m); + break; default: - return NULL; } } -static char* dump_integer(char* array, int x) +static int dump_mpz(mpz_ptr mpz) { - int nx = htonl(x); - memcpy(array, &nx, sizeof(int)); - return array + sizeof(int); -} - -static char* dump_mpz(char* array, mpz_ptr mpz) -{ int i; int len = abs(mpz->_mp_size); - array = dump_integer(array, mpz->_mp_size); + dump_integer(mpz->_mp_size); for(i=0; i_mp_d[i]); + dump_integer(mpz->_mp_d[i]); } - return array; + return; } +static int dump_string(char *s, int len) +{ + memcpy(&d_buf[d_ptr], s, len); + d_ptr += len; +} +static int dump_integer(int x) +{ + int nx = htonl(x); + dump_string((char *)&nx, sizeof(int)); +} + +int dump_ox_data(ox_data* m) +{ + dump_integer(OX_DATA); + dump_integer(-1); + dump_cmo(m->cmo); +} + +int dump_ox_command(ox_command* m) +{ + dump_integer(OX_COMMAND); + dump_integer(-1); + dump_integer(m->command); +} + int send_ox(ox_file_t s, ox *m) { int tag = m->tag; @@ -708,22 +968,31 @@ int send_ox_cmo(int fd, cmo* m) send_cmo(fd, m); } -int append_cell(cell* this, cell* cp); +/* send_cmo_xxx 関数群 */ +static int send_cmo_null(int fd, cmo_null* c) +{ + return 0; +} -cell* next_cell(cell* this) +static int send_cmo_int32(int fd, cmo_int32* m) { - return this->next; + send_int32(fd, m->i); } -static int send_cmo_error(int fd, cmo_error* c) +static int send_cmo_string(int fd, cmo_string* m) { - send_cmo(fd, (cmo *)c->li); + int len = (m->s != NULL)? strlen(m->s): 0; + send_int32(fd, len); + if (len > 0) { + write(fd, m->s, len); + } return 0; } -static int send_cmo_int32(int fd, cmo_int32* m) +static int send_cmo_mathcap(int fd, cmo_mathcap* c) { - send_int32(fd, m->i); + send_cmo(fd, c->ob); + return 0; } static int send_cmo_list(int fd, cmo_list* c) @@ -739,32 +1008,44 @@ static int send_cmo_list(int fd, cmo_list* c) return 0; } -static int send_cmo_mathcap(int fd, cmo_mathcap* c) +static int send_cmo_distributed_polynomial(int fd, cmo_distributed_polynomial* c) { - send_cmo(fd, (cmo *)c->li); - return 0; -} + cell* cp = c->head; + int len = length_cmo_list((cmo_list *)c); + send_int32(fd, len); + send_cmo(fd, c->ringdef); -static int send_cmo_null(int fd, cmo_null* c) -{ + while(cp != NULL) { + send_cmo(fd, cp->cmo); + cp = cp->next; + } return 0; } -static int send_cmo_string(int fd, cmo_string* m) +static int send_cmo_monomial32(int fd, cmo_monomial32* c) { - int len = strlen(m->s); - send_int32(fd, len); - if (len > 0) { - write(fd, m->s, len); - } - return 0; + int i; + int len = c->length; + send_int32(fd, len); + for(i=0; iexps[i]); + } + send_cmo(fd, c->coef); + return 0; } static int send_cmo_zz(int fd, cmo_zz* c) { send_mpz(fd, c->mpz); + return 0; } +static int send_cmo_error2(int fd, cmo_error2* c) +{ + send_cmo(fd, c->ob); + return 0; +} + /* CMOを送る. OX_tag は送信済*/ int send_cmo(int fd, cmo* c) { @@ -773,6 +1054,8 @@ int send_cmo(int fd, cmo* c) send_int32(fd, tag); switch(tag) { case CMO_NULL: + case CMO_ZERO: + case CMO_DMS_GENERIC: send_cmo_null(fd, c); /* 空の関数 */ break; case CMO_INT32: @@ -782,22 +1065,27 @@ int send_cmo(int fd, cmo* c) send_cmo_string(fd, (cmo_string *)c); break; case CMO_MATHCAP: + case CMO_ERROR2: + case CMO_RING_BY_NAME: + case CMO_INDETERMINATE: send_cmo_mathcap(fd, (cmo_mathcap *)c); break; case CMO_LIST: send_cmo_list(fd, (cmo_list *)c); break; + case CMO_MONOMIAL32: + send_cmo_monomial32(fd, (cmo_monomial32 *)c); + break; case CMO_ZZ: send_cmo_zz(fd, (cmo_zz *)c); break; - case CMO_ERROR2: - send_cmo_error(fd, (cmo_error *)c); + case CMO_DISTRIBUTED_POLYNOMIAL: + send_cmo_distributed_polynomial(fd, (cmo_distributed_polynomial *)c); break; default: } } -/* CMO_ZZ の例外の実装が不十分?? */ static int send_mpz(int fd, mpz_ptr mpz) { int i; @@ -825,20 +1113,6 @@ ox_command* new_ox_command(int sm_code) return m; } -char* dump_ox_data(char* array, ox_data* m) -{ - array = dump_integer(array, OX_DATA); - array = dump_integer(array, -1); - return dump_cmo(array, m->cmo); -} - -char* dump_ox_command(char* array, ox_command* m) -{ - array = dump_integer(array, OX_COMMAND); - array = dump_integer(array, -1); - return dump_integer(array, m->command); -} - #define MAX_TYPES 8 static int known_types[] = { -1, /* gate keeper */ @@ -851,20 +1125,20 @@ static int known_types[] = { CMO_ERROR2, }; -#define VER_STR "(CMO_LIST, 2, (CMO_LIST, (CMO_INT32, %d), (CMO_STRING, \"%s\")), (CMO_LIST, 7, (CMO_INT32, 1), (CMO_INT32, 2), (CMO_INT32, 4), (CMO_INT32, 5), (CMO_INT32, 17), (CMO_INT32, 20), (CMO_INT32, 2130706434)))\n" +#define ID_TEMP "(CMO_MATHCAP, (CMO_LIST, (CMO_LIST, (CMO_INT32, %d), (CMO_STRING, \"%s\"), (CMO_STRING, \"%s\"), (CMO_STRING, \"%s\")), (CMO_LIST, (CMO_INT32, 1), (CMO_INT32, 2), (CMO_INT32, 4), (CMO_INT32, 5), (CMO_INT32, 17), (CMO_INT32, 20), (CMO_INT32, 2130706434))))\n" -cmo* make_mathcap_object2(int version, char* id_string) +cmo* make_mathcap_object2(int ver, char* ver_s, char* sysname) { - cmo_list *li; - char buff[4096]; + cmo *cap; + char buff[8192]; setgetc(mygetc); - sprintf(buff, VER_STR, version, id_string); - setmode_mygetc(buff, 4096); - li = parse(); + sprintf(buff, ID_TEMP, ver, sysname, ver_s, getenv("HOSTTYPE")); + setmode_mygetc(buff, 8192); + cap = parse(); resetgetc(); - return (cmo *)new_cmo_mathcap(li); + return cap; } cmo* make_mathcap_object(int version, char* id_string) @@ -887,7 +1161,7 @@ cmo* make_mathcap_object(int version, char* id_string) append_cmo_list(li, (cmo *)li_ver); append_cmo_list(li, (cmo *)li_cmo); - return (cmo *)new_cmo_mathcap(li); + return (cmo *)new_cmo_mathcap((cmo *)li); } static int funcs(int cmo_type) @@ -915,7 +1189,7 @@ cmo* (*received_funcs[])(int fd) = { receive_cmo_mathcap, receive_cmo_list, receive_cmo_zz, - receive_cmo_error + receive_cmo_error2 }; cmo* receive_cmo2(int fd) @@ -926,53 +1200,47 @@ cmo* receive_cmo2(int fd) return foo(fd); } } -#endif +#endif + /* ファイルディスクリプタ fd の通信路での integer の byte order を決定する */ /* 実際には order (0,1,or 0xFF)をみてはいない */ -int decideByteOrder(int fd_read, int fd_write, int order) +int decideByteOrderClient(oxfd fd, int order) { - char zero = '\0'; + char zero = OX_BYTE_NETWORK_BYTE_ORDER; char dest; - write(fd_write, &zero, 1); - read(fd_read, &dest, 1); + read(fd, &dest, sizeof(char)); + write(fd, &zero, sizeof(char)); return 0; } /* Server 側ではこちらを用いる */ -int decideByteOrder2(int fd_read, int fd_write, int order) +/* いまの実装は dup されていることが前提になっている */ +int decideByteOrderServer(oxfd fd, int order) { - char zero = '\0'; + char zero = OX_BYTE_NETWORK_BYTE_ORDER; char dest; - read(fd_read, &dest, 1); - write(fd_write, &zero, 1); + write(fd, &zero, sizeof(char)); + read(fd, &dest, sizeof(char)); return 0; } -/* cmo と string の変換関数群 */ - -cmo_zz *new_cmo_zz_set_string(char *s) +/* cmo と string (ここではC言語のstring) の変換関数群 */ +char *convert_zz_to_string(cmo_zz *c) { - cmo_zz* c = new_cmo_zz_noinit(); - mpz_init_set_str(c->mpz, s, 10); - return c; -} - -char *CONVERT_ZZ_TO_CSTRING(cmo_zz *c) -{ return mpz_get_str(NULL, 10, c->mpz); } -char *CONVERT_CMO_TO_CSTRING(cmo *m) +char *convert_cmo_to_string(cmo *m) { switch(m->tag) { case CMO_ZZ: - return CONVERT_ZZ_TO_CSTRING((cmo_zz *)m); + return convert_zz_to_string((cmo_zz *)m); case CMO_INT32: - return CONVERT_INT_TO_CSTRING(((cmo_int32 *)m)->i); + return convert_int_to_string(((cmo_int32 *)m)->i); case CMO_STRING: return ((cmo_string *)m)->s; case CMO_NULL: - return CONVERT_NULL_TO_CSTRING(); + return convert_null_to_string(); default: fprintf(stderr, "sorry, not implemented CMO\n"); /* まだ実装していません. */ @@ -980,13 +1248,13 @@ char *CONVERT_CMO_TO_CSTRING(cmo *m) } } -char *CONVERT_NULL_TO_CSTRING() +char *convert_null_to_string() { static char* null_string = ""; return null_string; } -char *CONVERT_INT_TO_CSTRING(int integer) +char *convert_int_to_string(int integer) { char buff[1024]; char *s;