1 /*
2 *
3 * description of data file
4 *
5 * N max_grp max_mem
6 * G num yomi kanji
7 * M num grp secret yomi kanji phone
8 * #, balnk line : comment
9 * delimiter is TAB
10 */
11 #include "config.h"
12
13 #ifdef DEBUG
14 /*
15 #define DPRI(args...) fprintf(stderr, ## args)
16 */
17 #define DPRI1(a) fprintf(stderr, a)
18 #define DPRI2(a,b) fprintf(stderr, a,b)
19 #define DPRI3(a,b,c) fprintf(stderr, a,b,c)
20 #define DPRI4(a,b,c,d) fprintf(stderr, a,b,c,d)
21 #define DOUT(x) (void) fprintf x
22 #else
23 /*
24 #define DPRI(args...)
25 */
26 #define DPRI(a)
27 #define DPRI1(a)
28 #define DPRI2(a,b)
29 #define DPRI3(a,b,c)
30 #define DPRI4(a,b,c,d)
31 #define DOUT(x)
32 #endif
33
34 #define MSG(x) if (verbose) fprintf x
35 #define MSG1(a) if (verbose) fprintf(stderr, a)
36 #define MSG2(a,b) if (verbose) fprintf(stderr, a,b)
37 #define MSG3(a,b,c) if (verbose) fprintf(stderr, a,b,c)
38
39 #include <stdio.h>
40 #include <string.h>
41 #include <fcntl.h>
42 #include <sys/ioctl.h>
43 #include <signal.h>
44 #include <setjmp.h>
45 #include <unistd.h>
46 #include <sys/stat.h>
47 #include <time.h>
48
49 #if USE_TERMIO
50 #include <termio.h>
51 #define TERMIO struct termio
52 #endif
53
54 #if USE_TERMIOS
55 #include <termios.h>
56 #define TERMIO struct termios
57 #endif
58
59 #if HPUX
60 #include <sys/modem.h>
61 #endif
62
63 #ifdef HAVE_STDARG_H
64 # include <stdarg.h>
65 # define Va_start(a,b) va_start(a,b)
66 #else
67 # include <varargs.h>
68 # define Va_start(a,b) va_start(a)
69 #endif
70
71 #include "switchopt2.h"
72
73 #ifndef DEVICE
74 #define DEVICE "/dev/ttyS0"
75 #endif
76
77 #define BUFSIZE 16384
78 #define NUM_LEN 25
79 #define ARGSIZE 1000
80
81 #define KIND_NUM 1
82 #define KIND_506G 1
83
84 #define IGNORE_CF 1
85
86 #define SUM_BYTE 0
87 #define SUM_STR 1
88
89 int sum_mode = SUM_BYTE;
90
91 typedef struct stkind {
92 char *str;
93 int num;
94 } kind_t;
95
96 kind_t cel_kind[] =
97 {
98 {"506g", KIND_506G},
99 };
100 int kind = 0;
101
102 #define MAX_GRP 50
103 #define MAX_MEM 1000
104 #define STRLEN 100
105
106 #define ID_CELRW "CELRW"
107
108 #define MAX_BYTE 255
109 #define LEN_MEM_YOMI MAX_BYTE
110 #define LEN_MEM_KANJI MAX_BYTE
111 #define LEN_GRP_YOMI MAX_BYTE
112 #define LEN_GRP_KANJI MAX_BYTE
113
114 enum operation_mode {MODE_READ, MODE_WRITE,
115 MODE_VODA_SMS_READ, MODE_VODA_SMS_READ2,
116 MODE_VODA_SMS_WRITE,
117 MODE_VODA_SEND_FILE,
118 MODE_KDDI_BIN_READ,
119 MODE_KDDI_BIN_WRITE,
120 MODE_KDDI_SEND_FILE,
121 MODE_SCRIPT,};
122
123 #define EOL -1
124
125 /* 8 bit */
126 /* even parity, stop bit = 1 */
127 /* 600 bps */
128 #define CLEAR_BITS ~(CSIZE | PARODD | CSTOPB)
129 #define SET_BITS (CS8 | PARENB)
130
131 #define UCHAR unsigned char
132
133 #define ALARMW set_action(); alarm(timeout); if (setjmp(jump_env) == 0)
134 #define ALARMWT(x) set_action(); alarm(x); if (setjmp(jump_env) == 0)
135 #define ELSE else
136
137
138 void h_signal();
139
140
141 int timeout = 1;
142 jmp_buf jump_env;
143
144 char rcv_num_tbl[] = {'D', '1', '2', '3', '4', '5', '6', '7', '8', '9',
145 '0', '*', '#', 'A', 'B', 'C'};
146 char rev_num_tbl[] = {0x0a, 0x01, 0x02, 0x03, 0x04, 0x05,
147 0x06, 0x07, 0x08, 0x09};
148
149 int valid_baud[] = {600, 2400, 4800, 9600, 19200, 38400, 57600, 115200,};
150 #define NUM_BAUD (sizeof(valid_baud)/sizeof(int))
151
152
153 TERMIO pmode;
154 #if HPUX
155 mflag mmode;
156 #endif
157
158 int mfd;
159 int baud;
160 int force_baud = 0;
161 char *device = DEVICE;
162
163 static UCHAR buf[BUFSIZE];
164 static unsigned char dummy[MAX_BYTE];
165
166 /* counter for send memory */
167 int n_grp = 0;
168 int n_mem = 0;
169
170 int nogroup = 0; /* 1: Group is not supported */
171
172 int max_grp, max_mem;
173 int file_grp_num[MAX_GRP];
174 UCHAR file_grp_yomi[MAX_GRP][STRLEN];
175 UCHAR file_grp_kanji[MAX_GRP][STRLEN];
176
177 int secret;
178 int file_mem_num[MAX_MEM];
179 int file_mem_grp[MAX_MEM];
180 int file_mem_secret[MAX_MEM];
181 UCHAR file_mem_yomi[MAX_MEM][STRLEN];
182 UCHAR file_mem_kanji[MAX_MEM][STRLEN];
183 UCHAR file_mem_phone[MAX_MEM][STRLEN];
184 UCHAR file_mem_email[MAX_MEM][STRLEN];
185
186 int read_grp_num = 0, read_mem_num = 0;
187 int read_line;
188
189 int verbose = 1;
190
191 int yomi_len = 0;
192 int kanji_len = 0;
193 int ignore_group = 0;
194 int kanjicode = 0;
195
196 int mail_sum = 0;
197 unsigned int cksum = 0;
198
199 #define KDDI_ENTRY_NUM 32
200 unsigned char kddi_entry[KDDI_ENTRY_NUM][256];
201 int kddi_buf_size, kddi_ptr;
202
203 char *binary_fname;
204 unsigned char str_dial[256];
205
206 #if PORTWAIT
207 #include <sys/time.h>
208
mwait(msec)209 void mwait(msec)
210 int msec;
211 {
212 struct timeval tv_;
213 struct timezone tz_;
214 double d1,d2,d3;
215 double w = msec * 1000.;
216
217 (void) gettimeofday(&tv_,&tz_);
218 d1 = tv_.tv_sec;
219 d2 = tv_.tv_usec;
220
221 do{
222 (void) gettimeofday(&tv_,&tz_);
223 d3 = (double) (tv_.tv_sec - d1) * 1000000.
224 + (double) (tv_.tv_usec - d2);
225 }while ( d3 < w );
226 }
227 #endif /* PORTWAIT */
228
reset_mail_sum()229 void reset_mail_sum()
230 {
231 mail_sum = 0;
232 }
233
char2hex(c)234 int char2hex(c)
235 char c;
236 {
237 if (c >= '0' && c<='9') {
238 c -= '0';
239 } else if (c>='A' && c<='F') {
240 c = c - 'A' + 10;
241 } else if (c>='a' && c<='f') {
242 c = c - 'a' + 10;
243 } else {
244 (void) fprintf(stderr,"invalid character [%c]\n", c);
245 }
246
247 return (int) c;
248 }
249
ascii2hex(str)250 int ascii2hex(str)
251 char *str;
252 {
253 int c;
254
255 c = char2hex(*str++)<<4;
256 c += char2hex(*str++);
257 }
258
Tcgeta(fd,tios)259 void Tcgeta(fd,tios)
260 int fd;
261 TERMIO *tios;
262 {
263 #if USE_TERMIO
264 if (ioctl(fd, TCGETA, tios) < 0)
265 #endif
266 #if USE_TERMIOS
267 if (tcgetattr(fd, tios) < 0)
268 #endif
269 {
270 perror("TCGETA");
271 exit(-1);
272 }
273 }
274
Tcseta(fd,tios)275 void Tcseta(fd,tios)
276 int fd;
277 TERMIO *tios;
278 {
279 #if USE_TERMIO
280 if (ioctl(fd, TCSETAF, tios)< 0)
281 #endif
282 #if USE_TERMIOS
283 if (tcsetattr(fd, TCSAFLUSH, tios) < 0)
284 #endif
285 {
286 perror("TCSETAF");
287 exit(1);
288 }
289 }
290
Tcsetaw(fd,tios)291 void Tcsetaw(fd,tios)
292 int fd;
293 TERMIO *tios;
294 {
295 #if USE_TERMIO
296 if (ioctl(fd, TCSETAW, tios)< 0)
297 #endif
298 #if USE_TERMIOS
299 if (tcsetattr(fd, TCSADRAIN, tios) < 0)
300 #endif
301 {
302 perror("TCSETAW");
303 exit(1);
304 }
305 }
306
Flush()307 void Flush()
308 {
309 Tcgeta(mfd, &pmode);
310 Tcsetaw(mfd, &pmode);
311 }
312
change_baud(b)313 void change_baud(b)
314 int b;
315 {
316 Tcgeta(mfd,&pmode);
317
318 #if USE_TERMIO
319 pmode.c_cflag &= ~CBAUD;
320 pmode.c_cflag |= b;
321 #endif
322 #if USE_TERMIOS
323 cfsetospeed(&pmode, b);
324 cfsetispeed(&pmode, b);
325 #endif
326
327 Tcseta(mfd, &pmode);
328 }
329
OpenDevice()330 void OpenDevice()
331 {
332 int temp;
333
334 #ifdef __OpenBSD__
335 if ((mfd = open(device, O_RDWR)) < 0)
336 #else
337 if ((mfd = open(device, O_RDWR | O_NDELAY)) < 0)
338 #endif
339 {
340 perror("Can't open device");
341 exit(-1);
342 }
343
344 #if HPUX
345 if (ioctl(mfd, MCGETA, &mmode) == -1) {
346 perror("MCGETA:");
347 exit(1);
348 }
349 mmode |= (MDTR | MRTS);
350 if (ioctl(mfd, MCSETAF, &mmode) == -1) {
351 perror("MCSETAF:");
352 exit(1);
353 }
354 #endif
355
356 Tcgeta(mfd, &pmode);
357
358 pmode.c_cflag &= ~(HUPCL);
359 pmode.c_cflag |= CLOCAL;
360 pmode.c_iflag = IGNBRK ;
361 pmode.c_oflag = pmode.c_lflag = 0;
362 pmode.c_cc[VMIN] = 1;
363 pmode.c_cc[VTIME] = 0;
364
365 pmode.c_iflag &= ~(IXON | IXOFF | IXANY);
366 /*
367 pmode.c_iflag |= IXON | IXOFF | IXANY;
368 */
369
370 Tcseta(mfd, &pmode);
371
372 temp = mfd;
373 #ifndef __OpenBSD__
374 if ((mfd = open(device, O_RDWR)) < 0){
375 perror("Can't open device part2 ");
376 exit(-1);
377 }
378 close(temp);
379 #endif
380
381 change_baud(B600);
382
383 pmode.c_cflag &= CLEAR_BITS;
384 pmode.c_cflag |= SET_BITS;
385
386 Tcseta(mfd, &pmode);
387 }
388
389
CloseDevice()390 void CloseDevice()
391 {
392 Tcgeta(mfd, &pmode);
393
394 pmode.c_cflag &= ~CLOCAL;
395 pmode.c_cflag |= B0 | HUPCL;
396
397 Tcseta(mfd, &pmode);
398
399 #if HPUX
400 if (ioctl(mfd, MCGETA, &mmode) == -1) {
401 perror("MCGETA:");
402 exit(1);
403 }
404 mmode &= ~(MDTR | MRTS);
405 if (ioctl(mfd, MCSETAF, &mmode) == -1) {
406 perror("MCSETAF:");
407 exit(1);
408 }
409 #endif
410
411 close(mfd);
412 }
413
414 #ifdef HAVE_STDARG_H
VaSendHex(int h,...)415 void VaSendHex(int h, ...)
416 #else
417 void VaSendHex(va_alist)
418 va_dcl
419 #endif
420 {
421 va_list ap;
422 unsigned char c;
423 #ifdef HAVE_STDARG_H
424 Va_start(ap, h);
425 #else
426 int h;
427 Va_start(ap, h);
428 h = (int) va_arg(ap, long);
429 #endif
430
431 DPRI1("VaSendHex:");
432 while (h != (int) EOL) {
433 c = (unsigned char) h;
434
435 if (write(mfd, &c , 1) < 0) {
436 perror("VaSendHex:write");
437 h_signal();
438 }
439 DPRI2(" %02x",c);
440
441 h = (int) va_arg(ap, long);
442 }
443
444 va_end(ap);
445 DPRI1("\n");
446 }
447
h_signal()448 void h_signal()
449 {
450 signal(SIGINT, SIG_IGN);
451 /* reset DoCoMo */
452 VaSendHex (0x1f, 0x07, 0x0d, EOL);
453 CloseDevice();
454 (void) fprintf(stderr,"\n");
455 exit(-1);
456 }
457
change_baud_code(b)458 void change_baud_code(b)
459 int b;
460 {
461 sleep(1);
462 switch(b){
463 case 115200:
464 DOUT((stderr, "** 115200 baud **\n"));
465 change_baud(B115200);
466 break;
467
468 case 57600:
469 DOUT((stderr, "** 57600 baud **\n"));
470 change_baud(B57600);
471 break;
472
473 case 38400:
474 DOUT((stderr, "** 38400 baud **\n"));
475 change_baud(B38400);
476 break;
477
478 case 0x0f:
479 case 19200:
480 DOUT((stderr, "** 19200 baud **\n"));
481 change_baud(B19200);
482 break;
483
484 case 7: /* 9600 */
485 case 9600:
486 case 5: /* 4800 */
487 case 4800:
488 DPRI1("** 9600 baud **\n");
489 change_baud(B9600);
490 break;
491 #if 0
492 DPRI1("** 4800 baud **\n");
493 change_baud(B4800);
494 break;
495 #endif
496 case 3: /* 2400 */
497 case 2400:
498 DPRI1("** 2400 baud **\n");
499 change_baud(B2400);
500 break;
501 case 1: /* 600 */
502 case 600:
503 DPRI1("** 600 baud **\n");
504 change_baud(B600);
505 break;
506 default: /* ??? */
507 (void) fprintf(stderr,"code [%d] is unknown baud.\n",b);
508 h_signal();
509 break;
510 }
511 }
512
baud_code(b)513 int baud_code(b)
514 int b;
515 {
516 int x;
517
518 switch (baud) {
519 case 600:
520 x = 0x01;
521 break;
522 case 2400:
523 x = 0x03;
524 break;
525 case 4800:
526 x = 0x05;
527 break;
528 case 9600:
529 x = 0x07;
530 break;
531 }
532 return(x);
533 }
534
error_line()535 void error_line()
536 {
537 (void) fprintf(stderr,"error: line %d.\n",read_line);
538 exit(-1);
539 }
540
541 /*
542 * err: 2: do not warn
543 * 1: exit if encountered unexpected end of line
544 * 3: return if end of line detected
545 * return value: 0=found separator
546 * 1=found cr/lf
547 */
548
file_get_token(fp,err)549 int file_get_token(fp,err)
550 FILE *fp;
551 int err;
552 {
553 UCHAR *p,c;
554 int done;
555 int ret = 0;
556 int i = 0;
557
558 /* skip TAB, comment, linefeed */
559 done = 0;
560 do {
561 c = fgetc(fp);
562 switch(c){
563 case 0x09:
564 case 0x0a:
565 case 0x0d:
566 if (err == 3) {
567 *buf = '\0';
568 return 1;
569 }
570 break;
571
572 #if 0
573 case '#':
574 for(;fgetc(fp) != 0x0a && !feof(fp);) {
575 if (err && feof(fp)) {
576 error_line();
577 }
578 }
579 break;
580 #endif
581
582 default:
583 done = 1;
584 break;
585 }
586 } while(done == 0);
587
588 p = buf;
589
590 if (feof(fp)) {
591 *p = '\0';
592 if (err == 3 || err == 1) {
593 ret = 1;
594 }
595 return ret;
596 }
597
598 done = 0;
599 /* get one token : delimiter=TAB, linefeed */
600 do {
601 *p++ = c;
602
603 c = fgetc(fp);
604 switch (c) {
605 case 0x09:
606 done = 1;
607 break;
608
609 case 0x0a:
610 case 0x0d:
611 done = 1;
612 ret = 1;
613 if (err == 1) {
614 error_line();
615 }
616 break;
617 }
618
619 if (err && feof(fp)) {
620 error_line();
621 }
622
623 if (i++ > BUFSIZE-2) {
624 done = 1;
625 }
626 } while(done == 0);
627
628 *p = '\0';
629
630 if(!strcmp((char *) buf,"*NONE*")){
631 *buf = '\0';
632 }
633
634 return ret;
635 }
636
read_file(fname)637 void read_file(fname)
638 char *fname;
639 {
640 FILE *fp;
641 int eol = 0;
642
643 if ((fp = fopen(fname,"r")) == NULL){
644 (void) fprintf(stderr,"Can't open [%s].\n", fname);
645 exit(1);
646 }
647
648 read_line = 0; /* line num */
649 read_grp_num = 0;
650 read_mem_num = 0;
651 while (!feof(fp)){
652 (void) file_get_token(fp,0); /* command , ignore error(EOF) */
653 switch (buf[0]){
654 case 'N': /* max nums */
655 file_get_token(fp,1); /* max group,with error */
656 (void) sscanf((char *) buf,"%d", &max_grp);
657 file_get_token(fp,2); /* max memory,with error */
658 (void) sscanf((char *) buf,"%d", &max_mem);
659 read_line++;
660 break;
661
662 case 'G': /* group name */
663 file_get_token(fp,1); /* group num,with error */
664 (void) sscanf((char *) buf,"%d", &file_grp_num[read_grp_num]);
665 file_get_token(fp,1); /* yomi ,with error */
666 (void) strcpy((char *) file_grp_yomi[read_grp_num],(char *) buf);
667 file_get_token(fp,2); /* kanji ,with error */
668 (void) strcpy((char *) file_grp_kanji[read_grp_num],(char *) buf);
669
670 read_grp_num++;
671 read_line++;
672 break;
673
674 case 'M': /* memory name */
675 file_get_token(fp,1); /* memory num,with error */
676 (void) sscanf((char *) buf,"%d", &file_mem_num[read_mem_num]);
677 file_get_token(fp,1); /* group num,with error */
678 (void) sscanf((char *) buf,"%d", &file_mem_grp[read_mem_num]);
679 file_get_token(fp,1); /* secret */
680 (void) sscanf((char *) buf,"%d", &file_mem_secret[read_mem_num]);
681 file_get_token(fp,1); /* yomi ,with error */
682 (void) strcpy((char *) file_mem_yomi[read_mem_num],(char *) buf);
683 file_get_token(fp,1); /* kanji ,with error */
684 (void) strcpy((char *) file_mem_kanji[read_mem_num],(char *) buf);
685 eol = file_get_token(fp,3); /* phone ,with error */
686 (void) strcpy((char *) file_mem_phone[read_mem_num], (char *) buf);
687
688 if (!eol) {
689 eol = file_get_token(fp,3); /* email addr */
690 (void) strcpy((char *) file_mem_email[read_mem_num], (char *) buf);
691 } else {
692 file_mem_email[read_mem_num][0] = 0;
693 }
694
695 read_mem_num++;
696 read_line++;
697 break;
698 }
699 }
700
701 (void) fclose(fp);
702 }
703
RcvSwapNum(p,col,even)704 void RcvSwapNum(p, col, even)
705 UCHAR *p;
706 int col,even;
707 {
708 UCHAR c1,c2;
709 int i;
710 int r;
711
712 DOUT((stderr, "RcvSwapNum:"));
713 for(i=0; i<col - 1; i++){
714 if (read(mfd, &c1, 1) < 0) {
715 perror("RcvSwapNum:");
716 h_signal();
717 }
718 if (read(mfd, &c2, 1) < 0) {
719 perror("RcvSwapNum:");
720 h_signal();
721 }
722 DOUT((stderr, " %02x %02x",c1,c2));
723
724 mail_sum += (c1<<4)+c2;
725
726 *p++ = rcv_num_tbl[c2];
727 *p++ = rcv_num_tbl[c1];
728 }
729 DOUT((stderr, "\n"));
730 *p = '\0';
731
732 if (even) {
733 --p;
734 *p = '\0';
735 }
736 }
737
ReceiveMsg(n,d)738 void ReceiveMsg(n,d)
739 int n;
740 unsigned char d;
741 {
742 unsigned char c = 0;
743 int i=0;
744 int ok = 0;
745
746 DPRI1("recv:");
747 while(ok == 0){
748 if (read(mfd, &c, 1) < 0) {
749 perror("ReceiveMsg:read");
750 h_signal();
751 }
752 DPRI2(" %02x",c);
753 (void) fflush(stdout);
754 if (c == d) {
755 ok = 1;
756 }
757 }
758 i++;
759
760 while (i<n || n==0) {
761 if (read(mfd, &c, 1) < 0) {
762 perror("ReceiveMsg:read");
763 h_signal();
764 }
765 DPRI2(" %02x",c);
766 fflush(stdout);
767 i++;
768 }
769
770 DPRI1("\n");
771 }
772
RcvMsgMask(n,d,mask)773 void RcvMsgMask(n,d,mask)
774 int n;
775 unsigned char d,mask;
776 {
777 unsigned char c = 0;
778 int i=0;
779 int ok = 0;
780
781 DPRI1("recv:");
782 while(ok == 0){
783 if (read(mfd, &c, 1) < 0) {
784 perror("ReceiveMsg:read");
785 h_signal();
786 }
787 DPRI2(" %02x",c);
788 (void) fflush(stdout);
789 if ((c & mask) == (d & mask)) {
790 ok = 1;
791 }
792 }
793 i++;
794
795 while (i<n || n==0) {
796 if (read(mfd, &c, 1) < 0) {
797 perror("ReceiveMsg:read");
798 h_signal();
799 }
800 DPRI2(" %02x",c);
801 fflush(stdout);
802 i++;
803 }
804
805 DPRI1("\n");
806 }
807
rcv_digit()808 int rcv_digit()
809 {
810 UCHAR c1, c2;
811 int ret;
812
813 DOUT((stderr, "rcv_digit:"));
814
815 if (read(mfd, &c1, 1) < 0) {
816 perror("rcv_digit:read");
817 h_signal();
818 }
819 if (read(mfd, &c2, 1) < 0) {
820 perror("rcv_digit:read");
821 h_signal();
822 }
823
824 DOUT((stderr, " %02x %02x\n", c1, c2));
825
826 ret = c1*10 + c2;
827
828 return ret;
829 }
830
rcv_half()831 int rcv_half()
832 {
833 UCHAR c1;
834 int ret;
835
836 DOUT((stderr, "rcv_half:"));
837
838 if (read(mfd, &c1, 1) < 0) {
839 perror("rcv_half:read");
840 h_signal();
841 }
842
843 DOUT((stderr, " %02x\n", c1));
844
845 return c1;
846 }
847
rcv_buf(n,ignore)848 void rcv_buf(n,ignore)
849 int n;
850 int ignore;
851 {
852 UCHAR c = 0;
853 int i=0;
854
855 DOUT((stderr, "rcv_buf:"));
856 while ((i<n || n==0) && n < BUFSIZE) {
857 if (read(mfd, &c, 1) < 0) {
858 perror("rcv_buf:read");
859 h_signal();
860 }
861 DOUT((stderr, " %02x",c));
862 if (!ignore || c<0xc0 || c>0xcf) {
863 buf[i] = c;
864
865 if (i%2 == 1) {
866 mail_sum += (buf[i-1]<<4)+c;
867 }
868 i++;
869 }
870 }
871 DOUT((stderr, "\n"));
872 }
873
RcvBuf(n)874 void RcvBuf(n)
875 int n;
876 {
877 UCHAR c = 0;
878 int i=0;
879
880 DOUT((stderr, "RcvBuf:"));
881 while ((i<n || n==0) && n < BUFSIZE) {
882 if (read(mfd, &c, 1) < 0) {
883 perror("RcvBuf:read");
884 h_signal();
885 }
886 DOUT((stderr, " %02x",c));
887 buf[i] = c;
888
889 if (i%2 == 1) {
890 mail_sum += (buf[i-1]<<4)+c;
891 }
892 i++;
893 }
894 DOUT((stderr, "\n"));
895 }
896
RcvBufVerify(n,d)897 void RcvBufVerify(n,d)
898 int n;
899 UCHAR d;
900 {
901 UCHAR c = 0;
902 int i=0;
903 int ok = 0;
904
905 DPRI1("RcvBufVerify:");
906 while(ok == 0){
907 if (read(mfd, &c, 1) < 0) {
908 perror("RcvBufVerify:read");
909 h_signal();
910 }
911 DPRI2(" %02x",c);
912 (void) fflush(stdout);
913 if (c == d) {
914 ok = 1;
915 }
916 }
917 buf[i] = c;
918 i++;
919
920 while ((i<n || n==0) && n<BUFSIZE) {
921 if (read(mfd, &c, 1) < 0) {
922 perror("RcvBufVerify:read");
923 h_signal();
924 }
925 DPRI2(" %02x",c);
926 buf[i] = c;
927 i++;
928 }
929 DPRI1("\n");
930 }
931
932 /*
933 * received string = SJIS
934 */
RcvStr(n,str)935 void RcvStr(n,str)
936 int n;
937 unsigned char *str;
938 {
939 unsigned char c1 = 0, c2 = 0;
940 unsigned char *p = str;
941 int i=0;
942
943 DPRI1("RecvStr:");
944
945 while (i<n || n==0) {
946 if (read(mfd, &c1, 1) < 0) {
947 perror("RcvStr:read");
948 h_signal();
949 }
950 if (read(mfd, &c2, 1) < 0) {
951 perror("RcvStr:read");
952 h_signal();
953 }
954
955 *p = (c1 << 4) | c2;
956 i++;
957 DPRI2("%02x ",*p);
958 p++;
959 }
960 *p = '\0';
961
962 DPRI1("\n");
963 }
964
rcv_id(str)965 void rcv_id(str)
966 unsigned char *str;
967 {
968 unsigned char c1 = 0, c2 = 0;
969 unsigned char *p = str;
970 int i;
971
972 DOUT((stderr,"rcv_id:"));
973 for(i=0; i<5; i++){
974 (void) read(mfd, &c1, 1);
975 (void) read(mfd, &c2, 1);
976 *p++ = (c1 << 4) | c2;
977 DOUT((stderr, "%02x %02x ",c1,c2));
978 }
979
980 for(i=0; i<6; i++){
981 (void) read(mfd, &c1, 1);
982 (void) sprintf(p, "%02x", c1);
983 p+=2;
984 }
985 *p = '\0';
986
987 DOUT((stderr,"id=[%s]\n", str));
988 }
989
rcv_long()990 int rcv_long()
991 {
992 unsigned char c = 0;
993 int i;
994 int ret = 0;
995
996 DOUT((stderr, "rcv_long: "));
997
998 for(i=0; i<4; i++){
999 if (read(mfd, &c, 1) < 0) {
1000 perror("rcv_long:read");
1001 h_signal();
1002 }
1003 ret = (ret<<8)+c;
1004 DOUT((stderr, "%02x ",c));
1005 }
1006
1007 DOUT((stderr, "[%d]\n",ret));
1008
1009 return ret;
1010 }
1011
RcvShort()1012 int RcvShort()
1013 {
1014 unsigned char c1 = 0, c2 = 0;
1015 int ret;
1016
1017 if (read(mfd, &c1, 1) < 0) {
1018 perror("RcvShort:read");
1019 h_signal();
1020 }
1021 if (read(mfd, &c2, 1) < 0) {
1022 perror("RcvShort:read");
1023 h_signal();
1024 }
1025
1026 DOUT((stderr, "RcvShort: %02x %02x\n",c1,c2));
1027
1028 ret = (c1 << 8) + c2;
1029
1030 mail_sum += c1 + c2;
1031
1032 return ret;
1033 }
1034
1035
RcvByte()1036 int RcvByte()
1037 {
1038 unsigned char c1 = 0, c2 = 0;
1039 int ret;
1040
1041 if (read(mfd, &c1, 1) < 0) {
1042 perror("RcvByte:read");
1043 h_signal();
1044 }
1045 if (read(mfd, &c2, 1) < 0) {
1046 perror("RcvByte:read");
1047 h_signal();
1048 }
1049
1050 DOUT((stderr, "RcvByte: %02x %02x\n",c1,c2));
1051
1052 ret = (c1 << 4) + c2;
1053
1054 mail_sum += ret;
1055
1056 return ret;
1057 }
1058
RcvNumber()1059 int RcvNumber()
1060 {
1061 unsigned char c1 = 0, c2 = 0;
1062 int ret;
1063
1064 if (read(mfd, &c1, 1) < 0) {
1065 perror("RcvNumber:read");
1066 h_signal();
1067 }
1068 if (read(mfd, &c2, 1) < 0) {
1069 perror("RcvNumber:read");
1070 h_signal();
1071 }
1072
1073 DOUT((stderr, "RcvNumber: %02x %02x\n",c1,c2));
1074
1075 if (c1 == 0x08) {
1076 secret = 1;
1077 } else {
1078 secret = 0;
1079 }
1080
1081 c1 = RcvByte();
1082 ret = c2 * 100 + c1;
1083
1084 /* c1 already add by RcvByte */
1085 mail_sum += c2;
1086
1087 return ret;
1088 }
1089
RcvStrLen(p)1090 int RcvStrLen(p)
1091 UCHAR *p;
1092 {
1093 int len;
1094
1095 len = RcvByte();
1096 if (len) {
1097 RcvStr(len, p);
1098 } else {
1099 (void)strcpy((char *) p,"*NONE*");
1100 }
1101
1102 return len;
1103 }
1104
SendStrNum(s)1105 void SendStrNum(s)
1106 unsigned char *s;
1107 {
1108 unsigned char *p;
1109 unsigned char c;
1110
1111 DPRI1("sending ");
1112 p = s;
1113 while(*p != '\0') {
1114 if (*p < '0' && *p > '9') {
1115 (void) fprintf(stderr, "SendStrNum:illegal char [%c]\n", *p);
1116 h_signal();
1117 }
1118 c = rev_num_tbl[*p - '0'] + 0x90;
1119 if (write(mfd, &c , 1) < 0) {
1120 perror("SendStrNum:write");
1121 h_signal();
1122 }
1123 DPRI2("%02x ",c);
1124 p++;
1125 }
1126 DPRI1("\n");
1127 }
1128
SendDial(s)1129 void SendDial(s)
1130 unsigned char *s;
1131 {
1132 unsigned char c;
1133
1134 SendStrNum(s);
1135
1136 c = 0xaa;
1137 write(mfd, &c, 1);
1138 DPRI2("%02x : done\n",c);
1139 }
1140
SendSwapNum(s,col)1141 void SendSwapNum(s,col)
1142 UCHAR *s;
1143 int col;
1144 {
1145 UCHAR *p, *q;
1146 UCHAR c;
1147 int i;
1148
1149 /* initialize */
1150 for(i=0; i<BUFSIZE; i++){
1151 buf[i] = 0;
1152 }
1153
1154 /* swap */
1155 p = s;
1156 q = buf;
1157 while(*p != '\0') {
1158 *(q+1) = *p++;
1159 if (*p != '\0') {
1160 *q = *p++;
1161 }
1162 q+=2;
1163 }
1164
1165 DPRI1("sendSwapNum:");
1166 p = buf;
1167 i=0;
1168 for(i=0; i<col; i++){
1169 if (!((*p >= '0' && *p <= '9') || (*p >= 'A' && *p <= 'D') ||
1170 (*p == '*') || (*p == '#') || (*p == '\0'))) {
1171 (void) fprintf(stderr, "SendStrNum:illegal char [%c]\n", *p);
1172 h_signal();
1173 }
1174 if (*p == '\0') {
1175 c = 0;
1176 } else if (*p >= 'A' && *p <= 'C') {
1177 c = *p - 'A' + 0x0d;
1178 } else if (*p == 'D') {
1179 c = 0;
1180 } else if (*p == '#') {
1181 c = 0x0c;
1182 } else if (*p == '*') {
1183 c = 0x0b;
1184 } else {
1185 c = rev_num_tbl[*p - '0'];
1186 }
1187 if (write(mfd, &c , 1) < 0) {
1188 perror("SendSwapNum:write");
1189 h_signal();
1190 }
1191 DPRI2("%02x ",c);
1192 p++;
1193 }
1194 DPRI1("\n");
1195 }
1196
get_file_size()1197 int get_file_size()
1198 {
1199 struct stat st;
1200
1201 if (stat(binary_fname, &st) < 0) {
1202 (void) fprintf(stderr,"Can't stat [%s].\n", binary_fname);
1203 exit(1);
1204 }
1205
1206 return st.st_size;
1207 }
1208
SendHex(h)1209 void SendHex(h)
1210 int h;
1211 {
1212 unsigned char c;
1213
1214 c = (unsigned char) h;
1215
1216 if (write(mfd, &c , 1) < 0) {
1217 perror("SendHex:write");
1218 h_signal();
1219 }
1220 DPRI2("sendhex:%02x\n",c);
1221 }
1222
rev_cksum()1223 void rev_cksum()
1224 {
1225 unsigned int a;
1226
1227 a = 0xffff - cksum;
1228 SendHex(a>>8);
1229 SendHex(a&0xff);
1230 }
1231
1232
SendShort(s)1233 void SendShort(s)
1234 unsigned short s;
1235 {
1236 unsigned int i1, i2;
1237 unsigned char c1, c2;
1238
1239 i1 = (s>>8) & 0xff;
1240 i2 = s & 0xff;
1241 c1 = (UCHAR) i1;
1242 c2 = (UCHAR) i2;
1243
1244 if (write(mfd, &c1 , 1) < 0) {
1245 perror("SendShort:write");
1246 h_signal();
1247 }
1248 if (write(mfd, &c2 , 1) < 0) {
1249 perror("SendShort:write");
1250 h_signal();
1251 }
1252 DPRI3("SendShort :%02x %02x\n",c1,c2);
1253 }
1254
SendByte(s)1255 void SendByte(s)
1256 UCHAR s;
1257 {
1258 unsigned int i1, i2;
1259 unsigned char c1, c2;
1260
1261 i1 = (s>>4) & 0xf;
1262 i2 = s & 0xf;
1263 c1 = (UCHAR) i1;
1264 c2 = (UCHAR) i2;
1265
1266 if (write(mfd, &c1 , 1) < 0) {
1267 perror("SendByte:write");
1268 h_signal();
1269 }
1270 if (write(mfd, &c2 , 1) < 0) {
1271 perror("SendByte:write");
1272 h_signal();
1273 }
1274 DPRI3("SendByte :%02x %02x\n",c1,c2);
1275 }
1276
SendNumber(n)1277 void SendNumber(n)
1278 int n;
1279 {
1280 int i1,i2;
1281
1282 i1 = n / 100;
1283 i2 = n - i1*100;
1284
1285 SendByte((UCHAR) i1);
1286 SendByte((UCHAR) i2);
1287 }
1288
SendNumberSec(n,sec)1289 void SendNumberSec(n,sec)
1290 int n,sec;
1291 {
1292 int i1,i2;
1293
1294 i1 = n / 100;
1295 i2 = n - i1*100;
1296
1297 SendHex((UCHAR) sec * 0x08);
1298 SendHex((UCHAR) i1);
1299 SendByte((UCHAR) i2);
1300 }
1301
SendChar(c)1302 void SendChar(c)
1303 unsigned char c;
1304 {
1305 unsigned char c1, c2;
1306
1307 c1 = (c>>4) & 0xf;
1308 c2 = c & 0xf;
1309
1310 if (write(mfd, &c1 , 1) < 0) {
1311 perror("SendChar:write");
1312 h_signal();
1313 }
1314 if (write(mfd, &c2 , 1) < 0) {
1315 perror("SendChar:write");
1316 h_signal();
1317 }
1318 DPRI3("SendChar :%02x %02x\n",c1,c2);
1319 }
1320
SendStr(p)1321 void SendStr(p)
1322 unsigned char *p;
1323 {
1324 SendByte(strlen((char *) p));
1325
1326 while(*p != '\0'){
1327 SendChar(*p++);
1328 }
1329 }
1330
chk_kanji_2nd_byte(p,n)1331 int chk_kanji_2nd_byte(p,n)
1332 unsigned char *p;
1333 int n;
1334 {
1335 int i;
1336 int in = 0;
1337
1338 if (n>strlen(p)){
1339 n = strlen(p);
1340 }
1341
1342 for(i=0; i<n; i++, p++){
1343 if (!in && *p>=0x80) {
1344 in = 1;
1345 } else {
1346 in = 0;
1347 }
1348 }
1349
1350 return in;
1351 }
1352
SendStrN(p,len)1353 void SendStrN(p,len)
1354 unsigned char *p;
1355 int len;
1356 {
1357 int n;
1358
1359 if (len) {
1360 n = len;
1361 } else {
1362 n = strlen((char *) p);
1363 }
1364 DPRI3("SendStrN:max(%d),req(%d)\n",len,n);
1365
1366 if (chk_kanji_2nd_byte(p,n)) {
1367 n--;
1368 }
1369
1370 SendByte(n);
1371 while(n--){
1372 SendChar(*p++);
1373 }
1374 }
1375
SendStrNoLen(p)1376 void SendStrNoLen(p)
1377 unsigned char *p;
1378 {
1379 while(*p != '\0'){
1380 cksum += *p;
1381 SendChar(*p++);
1382 }
1383 }
1384
send_raw_str(p)1385 void send_raw_str(p)
1386 unsigned char *p;
1387 {
1388 unsigned char *q = p;
1389
1390 DOUT((stderr,"send_raw_str:"));
1391 while (*q) {
1392 if (write(mfd, q , 1) < 0) {
1393 perror("send_raw_str:write");
1394 h_signal();
1395 }
1396 DOUT((stderr,"%02x ", *q));
1397 cksum += *q;
1398 q++;
1399 }
1400 DOUT((stderr,"\n"));
1401 }
1402
send_short(len)1403 void send_short(len)
1404 int len;
1405 {
1406 int a;
1407
1408 a = len>>8;
1409 SendHex(a);
1410 cksum += a;
1411
1412 a = len&0xff;
1413 SendHex(a);
1414 cksum += a;
1415 }
1416
send_long(len)1417 void send_long(len)
1418 int len;
1419 {
1420 int i;
1421 int a;
1422
1423 for(i=0; i<4; i++){
1424 a = (len & 0xff000000)>>24;
1425 SendHex(a);
1426 cksum += a;
1427 len <<= 8;
1428 }
1429 }
1430
send_hexs(p)1431 void send_hexs(p)
1432 unsigned char *p;
1433 {
1434 unsigned char c;
1435 unsigned char q = 0;
1436 int valid;
1437 int two_digit = 0;
1438 int str_second = 0;
1439 int str_byte;
1440
1441 DOUT((stderr,"send_hexs:"));
1442 while(*p){
1443 c = *p++;
1444 valid = 1;
1445 if (c>='0' && c<='9') {
1446 q += c-'0';
1447 } else if (c>='A' && c<='F') {
1448 q += c-'A'+10;
1449 } else if (c>='a' && c<='f') {
1450 q += c-'a'+10;
1451 } else {
1452 if (two_digit) {
1453 if (write(mfd, &q , 1) < 0) {
1454 perror("send_hexs:write");
1455 h_signal();
1456 }
1457 DOUT((stderr, " %02x", q));
1458 if (sum_mode == SUM_STR) {
1459 if (!str_second) {
1460 str_byte = q<<4;
1461 } else {
1462 str_byte += q;
1463 cksum += str_byte;
1464 }
1465 } else {
1466 cksum += q;
1467 }
1468 str_second = 1-str_second;
1469 }
1470 q = 0;
1471 valid = 0;
1472 two_digit = 0;
1473 }
1474 if (valid) {
1475 if (two_digit) {
1476 if (write(mfd, &q , 1) < 0) {
1477 perror("send_hexs:write");
1478 h_signal();
1479 }
1480 DOUT((stderr, " %02x", q));
1481 if (sum_mode == SUM_STR) {
1482 if (!str_second) {
1483 str_byte = q<<4;
1484 } else {
1485 str_byte += q;
1486 cksum += str_byte;
1487 }
1488 } else {
1489 cksum += q;
1490 }
1491 str_second = 1-str_second;
1492 q = 0;
1493 } else {
1494 q<<=4;
1495 }
1496 two_digit = 1-two_digit;
1497 }
1498 }
1499 DOUT((stderr, "\n"));
1500 }
1501
comparen(p,q,n)1502 int comparen(p,q,n)
1503 unsigned char *p, *q;
1504 int n;
1505 {
1506 int ret = 0;
1507 int i;
1508
1509 for(i=0; i<n; i++){
1510 ret += (*p++ != *q++);
1511 }
1512
1513 return ret;
1514 }
1515
WaitHex(n,q)1516 void WaitHex(n,q)
1517 int n;
1518 unsigned char *q;
1519 {
1520 unsigned char c, *p;
1521 int i = 0;
1522
1523 p = (unsigned char *) malloc(sizeof(char)*n);
1524 for(i=0; i<n; i++){
1525 if (read(mfd, &c, 1) < 0) {
1526 perror("VaCompMsg:read");
1527 h_signal();
1528 }
1529 p[i] = c;
1530 DOUT((stderr," %02x",c));
1531 }
1532
1533 while(comparen(p,q,n)) {
1534 for(i=0; i<n-1; i++){
1535 p[i] = p[i+1];
1536 }
1537 if (read(mfd, &c, 1) < 0) {
1538 perror("VaCompMsg:read");
1539 h_signal();
1540 }
1541 p[n-1] = c;
1542 DOUT((stderr," %02x",c));
1543 }
1544
1545 DOUT((stderr,"\n"));
1546 }
1547
1548 #ifdef HAVE_STDARG_H
VaWait(int n,...)1549 void VaWait(int n, ...)
1550 #else
1551 void VaWait(va_alist)
1552 va_dcl
1553 #endif
1554 {
1555 va_list ap;
1556 unsigned char *q;
1557 int i = 0;
1558
1559 #ifdef HAVE_STDARG_H
1560 Va_start(ap, n);
1561 #else
1562 int n;
1563 Va_start(ap, n);
1564 n = (int) va_arg(ap, long);
1565 #endif
1566
1567 DOUT((stderr,"VaWait n=%d:", n));
1568
1569 q = (unsigned char *) malloc(sizeof(char)*n);
1570
1571 for(i=0; i<n; i++){
1572 q[i] = (unsigned char) va_arg(ap, long);
1573 }
1574 va_end(ap);
1575
1576 WaitHex(n, q);
1577 }
1578
1579 #ifdef HAVE_STDARG_H
VaCompMsg(int n,...)1580 int VaCompMsg(int n, ...)
1581 #else
1582 int VaCompMsg(va_alist)
1583 va_dcl
1584 #endif
1585 {
1586 va_list ap;
1587 unsigned char c,d;
1588 int ret = 1;
1589 int i = 0;
1590
1591 #ifdef HAVE_STDARG_H
1592 Va_start(ap, n);
1593 #else
1594 int n;
1595 Va_start(ap, n);
1596 n = (int) va_arg(ap, long);
1597 #endif
1598
1599 DPRI1("VaCompMsg:");
1600
1601 while (i < n) {
1602 if (read(mfd, &c, 1) < 0) {
1603 perror("VaCompMsg:read");
1604 h_signal();
1605 }
1606 d = (unsigned char) va_arg(ap, long);
1607 DPRI3(" read[%02x]=%02x?", c, d);
1608
1609 if (c != d) {
1610 ret = 0;
1611 }
1612 i++;
1613 }
1614
1615 va_end(ap);
1616 DPRI1("\n");
1617
1618 return(ret);
1619 }
1620
1621 #ifdef HAVE_STDARG_H
msg_wait_compare(int n,...)1622 int msg_wait_compare(int n, ...)
1623 #else
1624 int msg_wait_compare(va_alist)
1625 va_dcl
1626 #endif
1627 {
1628 va_list ap;
1629 unsigned char c,d;
1630 int ret = 1;
1631 int i = 0;
1632
1633 #ifdef HAVE_STDARG_H
1634 Va_start(ap, n);
1635 #else
1636 int n;
1637 Va_start(ap, n);
1638 n = (int) va_arg(ap, long);
1639 #endif
1640
1641 DPRI1("msg_wait_compare:");
1642
1643 d = (unsigned char) va_arg(ap, long);
1644 VaWait(1, d);
1645 i++;
1646
1647 while (i < n) {
1648 if (read(mfd, &c, 1) < 0) {
1649 perror("msg_wait_compare:read");
1650 h_signal();
1651 }
1652 d = (unsigned char) va_arg(ap, long);
1653 DPRI3(" read[%02x]=%02x?", c, d);
1654
1655 if (c != d) {
1656 ret = 0;
1657 }
1658 i++;
1659 }
1660
1661 va_end(ap);
1662 DPRI1("\n");
1663
1664 return(ret);
1665 }
SendPasswdSuccess()1666 void SendPasswdSuccess()
1667 {
1668 DOUT((stderr, "password success: "));
1669 VaSendHex(0x6c, 0x03, EOL);
1670 }
1671
SendMaxGroup(cmd,max_mem,max_grp)1672 void SendMaxGroup(cmd, max_mem, max_grp)
1673 int cmd, max_mem, max_grp;
1674 {
1675 DPRI1("SendMaxGroup\n");
1676 VaSendHex(cmd, 0x0d, 0x00, 0x02, EOL);
1677 /*
1678 * 00 00 : NO YOMI & KANJI
1679 * 00 01 : YOMI ONLY
1680 * 00 02 : KANJI ONLY
1681 * 00 03 : YOMI & KANJI
1682 */
1683 VaSendHex(0x00, 0x07, EOL);
1684 SendNumber(max_mem); /* max memory */
1685
1686 VaSendHex(0x00, 0x07, EOL); /* enable kanji */
1687 SendByte(LEN_MEM_YOMI);
1688 SendByte(LEN_MEM_KANJI);
1689
1690 SendByte(max_grp); /* max group */
1691 SendByte(LEN_GRP_YOMI);
1692 SendByte(LEN_GRP_KANJI);
1693
1694 SendStrNoLen(ID_CELRW);
1695 send_hexs("09 09 09 09 09 09");
1696 }
1697
SendGroupName(num,yomi,kanji)1698 void SendGroupName(num, yomi, kanji)
1699 int num;
1700 UCHAR *yomi, *kanji;
1701 {
1702 MSG2("sending group #%d\n",num);
1703
1704 VaSendHex(0x6c, 0x0a, EOL);
1705 SendByte(num);
1706 VaSendHex(0x00, 0x01, EOL);
1707 SendStr(yomi);
1708
1709 VaSendHex(0x00, 0x03, EOL);
1710 SendStr(kanji);
1711 }
1712
SendMemory(num,grp,sec,yomi,kanji,phone)1713 void SendMemory(num, grp, sec, yomi, kanji, phone)
1714 int num,grp,sec;
1715 UCHAR *yomi, *kanji, *phone;
1716 {
1717 int col;
1718 int i,j;
1719
1720 MSG2("sending memory #%d\n",num);
1721 DPRI4("%s %s %s\n", yomi, kanji, phone);
1722
1723 /*
1724 * send memory dial
1725 */
1726 if (*phone) {
1727 VaSendHex(0x6c, 0x06, EOL);
1728 SendNumberSec(num,sec);
1729 VaSendHex(0x00, 0x01, EOL);
1730 if (*yomi) {
1731 DPRI3("yomi_len=%d len=%d\n", yomi_len, strlen(yomi));
1732 if (yomi_len && (strlen(yomi)>yomi_len)) {
1733 SendStrN(yomi,yomi_len);
1734 } else {
1735 SendStr(yomi);
1736 }
1737 } else {
1738 VaSendHex(0x00, 0x00, EOL);
1739 }
1740
1741 col = strlen((char *) phone);
1742 i = (col + 1) / 2 +1;
1743 j = (i-1)*2 - col;
1744 SendShort((unsigned short)i);
1745 if (col) {
1746 SendHex(j*8);
1747 SendHex(0x00);
1748
1749 SendSwapNum(phone,(i-1)*2);
1750 }
1751 SendByte(grp);
1752
1753 if (kanjicode) {
1754 VaSendHex(0x00, kanjicode, EOL);
1755 } else {
1756 VaSendHex(0x00, 0x03, EOL);
1757 }
1758
1759 if (*kanji) {
1760 if (kanji_len && (strlen(kanji) > kanji_len)) {
1761 SendStrN(kanji, kanji_len);
1762 } else {
1763 SendStr(kanji);
1764 }
1765 } else {
1766 VaSendHex(0x00, 0x00, EOL);
1767 }
1768 }
1769 }
1770
SendEndOfGroup()1771 void SendEndOfGroup()
1772 {
1773 VaSendHex(0x6c, 0x0c, EOL);
1774 }
1775
SendOneGroup()1776 int SendOneGroup()
1777 {
1778 int ret = 0;
1779
1780 /* skip no_data area */
1781 while(n_grp<read_grp_num &&
1782 *file_grp_yomi[n_grp] == 0 &&
1783 *file_grp_kanji[n_grp] == 0
1784 ) {
1785 n_grp++;
1786 }
1787 if (n_grp < read_grp_num) {
1788 SendGroupName(file_grp_num[n_grp],file_grp_yomi[n_grp],file_grp_kanji[n_grp]);
1789 n_grp++;
1790 } else {
1791 SendEndOfGroup();
1792 ret = 1;
1793 }
1794
1795 return ret;
1796 }
1797
SendEndOfMemory()1798 void SendEndOfMemory()
1799 {
1800 VaSendHex(0x6c, 0x08, EOL);
1801 }
1802
SendOneMemory()1803 int SendOneMemory()
1804 {
1805 int ret = 0;
1806
1807 /* skip no_data area */
1808 while(n_mem<read_mem_num &&
1809 *file_mem_phone[n_mem] == 0) {
1810 n_mem++;
1811 }
1812
1813 if (n_mem < read_mem_num) {
1814 SendMemory(file_mem_num[n_mem],file_mem_grp[n_mem],
1815 file_mem_secret[n_mem],
1816 file_mem_yomi[n_mem],file_mem_kanji[n_mem],
1817 file_mem_phone[n_mem]);
1818 n_mem++;
1819 } else {
1820 SendEndOfMemory();
1821 ret = 1;
1822 }
1823
1824 return ret;
1825 }
1826
1827 #ifdef HAVE_STDARG_H
SendAck(int h,...)1828 void SendAck(int h, ...)
1829 #else
1830 void SendAck(va_alist)
1831 va_dcl
1832 #endif
1833 {
1834 va_list ap;
1835 unsigned char c;
1836 static UCHAR sendbuf[BUFSIZE];
1837 int i = 0, j , differ;
1838 UCHAR *p, *q;
1839 #ifdef HAVE_STDARG_H
1840 Va_start(ap, h);
1841 #else
1842 int h;
1843 Va_start(ap, h);
1844 h = (int) va_arg(ap, long);
1845 #endif
1846
1847 q = sendbuf;
1848
1849 DPRI1("SendAck:");
1850 while (h != (int) EOL) {
1851 c = (unsigned char) h;
1852 *q++ = c;
1853 i++;
1854
1855 if (write(mfd, &c , 1) < 0) {
1856 perror("SendAck:write");
1857 h_signal();
1858 }
1859 DPRI2(" %02x",c);
1860
1861 h = (int) va_arg(ap, long);
1862 }
1863
1864 va_end(ap);
1865 DPRI1("\n");
1866
1867 RcvBuf(i);
1868
1869 differ = 0;
1870 DPRI1("Verify :");
1871 for(j=1, p=buf+1, q=sendbuf+1; j<i; j++, p++, q++){
1872 DPRI2(" %02x",*p);
1873 if (*p != *q) {
1874 differ = 1;
1875 }
1876 }
1877 DPRI1("\n");
1878 if (differ) {
1879 (void) fprintf(stderr,"Ack Error!\n");
1880 h_signal();
1881 }
1882 }
1883
GetMaxNum(cmd,num,grp)1884 void GetMaxNum(cmd,num,grp)
1885 int cmd;
1886 int *num, *grp;
1887 {
1888 int flag;
1889 int len_yomi, len_kanji;
1890 int len_tel, len_grp;
1891
1892 DPRI1("GetMaxNum\n");
1893 ReceiveMsg(4,cmd);
1894 flag = RcvShort();
1895 #ifdef DEBUG
1896 if (flag & 0x0001) {
1897 (void) fprintf(stderr,"YOMI enabled\n");
1898 }
1899 if (flag & 0x0002) {
1900 (void) fprintf(stderr,"KANJI enabled\n");
1901 }
1902 if (flag & 0x0004) {
1903 (void) fprintf(stderr,"group enabled\n");
1904 }
1905 #endif
1906 *num = RcvNumber();
1907
1908 flag = RcvByte();
1909 #ifdef DEBUG
1910 if (flag & 0x0001) {
1911 (void) fprintf(stderr,"JIS8\n");
1912 }
1913 if (flag & 0x0002) {
1914 (void) fprintf(stderr,"SJIS\n");
1915 }
1916 if (flag & 0x0004) {
1917 (void) fprintf(stderr,"???\n");
1918 }
1919 #endif
1920
1921 len_yomi = RcvByte();
1922 len_tel = RcvByte();
1923 DPRI3("mem: len #yomi=%d #tel=%d\n", len_yomi, len_tel);
1924
1925 if (!yomi_len) {
1926 yomi_len = len_yomi;
1927 }
1928
1929 *grp = RcvByte();
1930 len_grp = RcvByte();
1931 len_kanji = RcvByte();
1932 DPRI3("grp: len #grp=%d #kanji=%d\n", len_grp, len_kanji);
1933
1934 if (!kanji_len) {
1935 kanji_len = len_kanji;
1936 }
1937
1938 /* cellular ID */
1939 DOUT((stderr, "cellular ID:"));
1940 RcvStr(5, dummy);
1941 RcvStr(3, &dummy[11]);
1942 DOUT((stderr, "ID=%s", dummy));
1943 DOUT((stderr, "%02x%02x%02x\n", dummy[11], dummy[12], dummy[13]));
1944 }
1945
1946
GetGroup()1947 int GetGroup()
1948 {
1949 static char kana[MAX_BYTE], kanji[MAX_BYTE];
1950 int grp_num;
1951 int len;
1952
1953 /*
1954 * send 64 07 : get group
1955 * result
1956 * 6c 0a : group exists
1957 * 6c 0c : group end
1958 */
1959 VaSendHex(0x64, 0x07, EOL);
1960
1961 #if PORTWAIT
1962 mwait(400);
1963 #endif
1964 if (msg_wait_compare(2,0x6c,0x0c)) {
1965 DPRI1("***** group end.\n");
1966 return 0;
1967 }
1968
1969 grp_num = RcvByte();
1970 DPRI2("* group number:%d\n",grp_num);
1971 MSG2("getting group #%d\n",grp_num);
1972
1973 ReceiveMsg(2,0x00);
1974 len = RcvStrLen(kana);
1975 DPRI2("kana=[%s]\n",kana);
1976
1977 ReceiveMsg(2,0x00);
1978 len += RcvStrLen(kanji);
1979 DPRI2("kanji=[%s]\n",kanji);
1980
1981 if (len) {
1982 (void) printf("G\t%d\t%s\t%s\n",
1983 grp_num, kana, kanji);
1984 }
1985
1986 return 1;
1987 }
1988
1989
GetMemory()1990 int GetMemory()
1991 {
1992 static char kana[MAX_BYTE], kanji[MAX_BYTE], phone[MAX_BYTE];
1993 int grp_num;
1994 int mem_num;
1995 int col,even;
1996
1997 /*
1998 * send 64 06 : read memory dial
1999 */
2000 VaSendHex(0x64, 0x06, EOL);
2001
2002 #if PORTWAIT
2003 mwait(600);
2004 #endif
2005 /*
2006 * 6c 06 : memory exists
2007 * 6c 08 : memory end
2008 */
2009 if (msg_wait_compare(2,0x6c,0x08)) {
2010 DPRI1("***** memory end.\n");
2011 return 0;
2012 }
2013
2014 mem_num = RcvNumber();
2015 DPRI3("* memory number:%d secret=%d\n",mem_num,secret);
2016 MSG2("getting memory #%d\n",mem_num);
2017
2018 ReceiveMsg(2, 0x00);
2019
2020 RcvStrLen(kana);
2021 DPRI2("furigana=[%s]\n",kana);
2022
2023 col = RcvShort();
2024 if (col) {
2025 RcvBuf(2);
2026 even = buf[0];
2027
2028 RcvSwapNum(phone, col, even);
2029 DPRI2("phone=[%s]\n",phone);
2030 } else {
2031 (void) strcpy(phone, "*NONE*");
2032 }
2033
2034 if (!nogroup) {
2035 grp_num = RcvByte();
2036 DPRI2("group number:%d\n",grp_num);
2037
2038 ReceiveMsg(2, 0x00);
2039 RcvStrLen(kanji);
2040 DPRI2("kanji=[%s]\n",kanji);
2041 } else {
2042 RcvBuf(2);
2043 (void) strcpy(kanji, "*NONE*");
2044 }
2045
2046 if (col) {
2047 (void) printf("M\t%d\t%d\t%d\t%s\t%s\t%s\n",
2048 mem_num,grp_num,secret, kana, kanji, phone);
2049 }
2050
2051 return 1;
2052 }
2053
RecvAck6c()2054 void RecvAck6c()
2055 {
2056 }
2057
RecvAck64()2058 void RecvAck64()
2059 {
2060 static UCHAR ackbuf[BUFSIZE];
2061 int i = 0;
2062
2063 RcvBuf(1);
2064 switch(buf[0]){
2065 case 0x01:
2066 switch (kind) {
2067 case KIND_506G:
2068 sleep(1);
2069 break;
2070 }
2071 VaSendHex(0x6c, buf[0], EOL);
2072 break;
2073
2074 case 0x02:
2075 case 0x0e:
2076 ackbuf[i++] = buf[0];
2077 RcvBuf(1);
2078 VaSendHex(0x6c, ackbuf[0], buf[0], EOL);
2079 break;
2080 }
2081 }
2082
cb_timeout(sig)2083 void cb_timeout(sig)
2084 int sig;
2085 {
2086 /*
2087 signal(sig,SIG_IGN);
2088 */
2089
2090 (void) fprintf(stderr,"alarm catch\n");
2091
2092 longjmp(jump_env,1);
2093 }
2094
set_action()2095 void set_action()
2096 {
2097 #ifdef HAVE_SIGACTION
2098 struct sigaction new_action;
2099
2100 new_action.sa_handler = cb_timeout;
2101 sigemptyset (&new_action.sa_mask);
2102 new_action.sa_flags = SA_NODEFER;
2103
2104 (void) sigaction(SIGALRM, &new_action, NULL);
2105 #else
2106 signal(SIGALRM,cb_timeout);
2107 #endif
2108 }
2109
ign_action()2110 void ign_action()
2111 {
2112 #ifdef HAVE_SIGACTIOON
2113 struct sigaction new_action;
2114
2115 new_action.sa_handler = SIG_IGN;
2116 sigemptyset (&new_action.sa_mask);
2117 new_action.sa_flags = SA_NODEFER;
2118
2119 (void) sigaction(SIGALRM, &new_action, NULL);
2120 #else
2121 signal(SIGALRM,SIG_IGN);
2122 #endif
2123 }
2124
RecvAck()2125 void RecvAck()
2126 {
2127 int done = 0;
2128
2129 while(!done){
2130 RcvBuf(1);
2131 switch(buf[0]){
2132 case 0x6c: /* extend mode 1 */
2133 RecvAck6c();
2134 done=1;
2135 break;
2136 case 0x64: /* extend mode 2 */
2137 RecvAck64();
2138 done=1;
2139 break;
2140 case 0x60:
2141 ign_action();
2142 VaSendHex(0x61, EOL);
2143 SendStrNoLen(ID_CELRW);
2144 SendStrNoLen(" ");
2145 RcvBuf(2); /* 64 08 */
2146 VaSendHex(0x6c, 0x0b, 0x00, 0x00, EOL);
2147 RcvBuf(4); /* 6c 0c 64 05 */
2148 VaSendHex(0x6c, 0x05, 0x00, 0x03, 0x00, 0x00, EOL);
2149
2150 nogroup=1;
2151 done=1;
2152 break;
2153 }
2154 }
2155 }
2156
SendMemoryAck(code)2157 int SendMemoryAck(code)
2158 int code;
2159 {
2160 int ret = 1;
2161 unsigned char c;
2162
2163 if (read(mfd, &c, 1) < 0) {
2164 perror("SendMemoryAck:read");
2165 h_signal();
2166 }
2167 if (c != 0x64) {
2168 ret = 0;
2169 }
2170 DOUT((stderr, "required:64, received:%02x\n", c));
2171
2172 if (read(mfd, &c, 1) < 0) {
2173 perror("SendMemoryAck:read");
2174 h_signal();
2175 }
2176 if (c == 0x0b) {
2177 ret = 0;
2178 }
2179 if (c != code && c != 0x0b && c != 0x00) { /* ok nor incomplete */
2180 ret = 0;
2181 }
2182 DPRI3("required:%02x, received:%02x\n", code, c);
2183
2184 return(ret);
2185 }
2186
establish_connection()2187 void establish_connection()
2188 {
2189 MSG1("establishing connection ...");
2190 /* make connection */
2191 SendHex(0xa8);
2192 sleep(2);
2193 SendHex(0xa8);
2194
2195 #if PORTWAIT
2196 mwait(200);
2197 #endif
2198
2199 /* recv 64 01 */
2200 /* send 6c 01 */
2201 RecvAck();
2202 MSG1("done\n");
2203
2204 }
2205
StoreCellular()2206 void StoreCellular()
2207 {
2208 int temp_mem = 999, temp_grp = 99;
2209 int x;
2210 int eog;
2211
2212 establish_connection();
2213
2214 sleep(2);
2215
2216 ALARMW {
2217 RcvMsgMask(1,0xa3,0x7f);
2218 }
2219
2220 /* enter passcode on cellular */
2221 (void) fprintf(stderr,"Input your pass code into cellular\n");
2222
2223 /*
2224 sleep(2);
2225 */
2226 /* recv 64 02 xx: set baud rate */
2227 /* send 6c 02 xx: set baud rate */
2228 RcvBufVerify(3,0x64);
2229
2230 /* request speed */
2231 if (force_baud) {
2232 x = baud_code(baud);
2233 } else {
2234 x = buf[2];
2235 }
2236 VaSendHex(0x6c, 0x02, x, EOL);
2237
2238 /* change baud */
2239 change_baud_code(x);
2240
2241 /* any 4 digit */
2242 (void) fprintf(stderr,"Input any 4 digit into cellular\n");
2243
2244 /* recv: 64 03 9a 9a 9a 9a 64 04 */
2245 RcvBuf(8);
2246
2247 /* send: 6c 03 */
2248 SendPasswdSuccess();
2249
2250 /* recv 64 0e 02 & ack*/
2251 /* send 6c 0e 02 */
2252 ALARMW {
2253 RecvAck();
2254 } ELSE {
2255 ALARMW {
2256 /* for HD-50S */
2257 VaSendHex(0x64, 0x0e, 0x03, 0x01, 0x00, EOL);
2258 ReceiveMsg(5,0x6c);
2259 } ELSE {
2260 /* for J-PE02 */
2261 RecvAck();
2262 }
2263 }
2264
2265 /* send max grp and num */
2266
2267 if (!nogroup) {
2268 /* group num and memory num to send are identical with that of read */
2269 ALARMW {
2270 GetMaxNum(0x64, &temp_mem, &temp_grp);
2271 SendMaxGroup(0x6c, temp_mem, temp_grp);
2272 }
2273 ign_action();
2274
2275 DPRI3("cel: grp=%d, mem=%d\n", temp_grp, temp_mem);
2276
2277 if (!ignore_group) {
2278 /* send multiple group */
2279 eog = 0;
2280 while(eog == 0){
2281 /* 64 07 : get group */
2282 if (!SendMemoryAck(0x07)) {
2283 eog=1;
2284 } else {
2285 eog = SendOneGroup();
2286 }
2287 }
2288 } else {
2289 /* recv 64 07 */
2290 RcvBuf(2);
2291 SendEndOfGroup();
2292 }
2293 }
2294
2295 /* send multiple memory */
2296 eog = 0;
2297 while(eog == 0){
2298 /* 64 06 : get memory */
2299 if (!SendMemoryAck(0x06)) {
2300 eog=1;
2301 n_mem--;
2302 (void) fprintf(stderr, "Write error occurred while sending memory\n");
2303 (void) fprintf(stderr,"%d\t%d\t%d\t%s\t%s\t%s.\n",
2304 file_mem_num[n_mem],
2305 file_mem_grp[n_mem],
2306 file_mem_secret[n_mem],
2307 file_mem_yomi[n_mem],
2308 file_mem_kanji[n_mem],
2309 file_mem_phone[n_mem]);
2310 } else {
2311 eog = SendOneMemory();
2312 }
2313 }
2314
2315 sleep(2);
2316 /* memory copy done */
2317 VaSendHex(0xa8, EOL);
2318
2319 (void) fprintf(stderr,"send memory done.\n");
2320 }
2321
ReadCellular(passwd)2322 void ReadCellular(passwd)
2323 char *passwd;
2324 {
2325 int x;
2326 unsigned char next;
2327
2328 establish_connection();
2329
2330 /*
2331 sleep(2);
2332 */
2333 ALARMW {
2334 RcvMsgMask(1,0xa3,0x7f);
2335 }
2336
2337 sleep(2);
2338
2339 /* request speed */
2340 /* send 64 02 xx */
2341 /* recv 6c 02 xx */
2342
2343 x = baud_code(baud);
2344 VaSendHex(0x64, 0x02, x, EOL);
2345 #if PORTWAIT
2346 mwait(200);
2347 #endif
2348 RcvBufVerify(3,0x6c);
2349
2350 /* change baud */
2351 change_baud_code(buf[2]);
2352
2353 sleep(2);
2354
2355 /* send passwd */
2356 MSG1("sending password\n");
2357 VaSendHex(0x64, 0x03, EOL);
2358 SendStrNum(passwd);
2359 VaSendHex(0x64, 0x04, EOL);
2360
2361 #if PORTWAIT
2362 mwait(200);
2363 #endif
2364
2365 /*
2366 * recv 6c 03 => success
2367 * recv 6c 04 => fail
2368 */
2369 if (msg_wait_compare(2,0x6c,0x03)) {
2370 (void) fprintf(stderr,"passwd OK\n");
2371 } else {
2372 (void) fprintf(stderr,"invalid passwd\n");
2373 h_signal();
2374 }
2375
2376 /*
2377 * read group
2378 * send 64 0e 02
2379 * recv 6c 0e 02
2380 */
2381 VaSendHex(0x64, 0x0e, 0x02, EOL);
2382 #if PORTWAIT
2383 mwait(200);
2384 #endif
2385 /* for HD-50S hack */
2386 ALARMW {
2387 /* for HD-50S hack */
2388 /*
2389 ReceiveMsg(3,0x6c);
2390 */
2391 RcvBuf(1);
2392 switch(buf[0]){
2393 case 0x6c:
2394 RcvBuf(1);
2395 if (buf[0] != 0x07) {
2396 RcvBuf(1);
2397 }
2398 break;
2399 case 0x64:
2400 /* for HD-50S */
2401 RcvBuf(4);
2402 VaSendHex(0x6c, buf[0], buf[1], buf[2], buf[3], EOL);
2403 break;
2404 }
2405 } ELSE {
2406 /* DP144 */
2407 VaSendHex(0x60, EOL);
2408 RcvBuf(1);
2409 RcvStr(8, dummy);
2410 DOUT((stderr,"str=[%s]\n",dummy));
2411 ALARMW {
2412 RcvStr(8, dummy);
2413 DOUT((stderr,"additional str=[%s]\n",dummy));
2414 } ELSE {
2415 }
2416 VaSendHex(0x64, 0x08, EOL);
2417 RcvBuf(4); /* 6c 0b 00 00 */
2418 VaSendHex(0x6c, 0x0c, 0x64, 0x05, EOL);
2419 RcvBuf(6); /* 6c 05 00 03 00 00 */
2420
2421 nogroup = 1;
2422 }
2423
2424 /*
2425 * send max group num
2426 * send 64 0d
2427 */
2428 SendMaxGroup(0x64, 999, 99);
2429
2430 #if PORTWAIT
2431 mwait(1000);
2432 #endif
2433
2434 ALARMW {
2435 GetMaxNum(0x6c, &max_mem, &max_grp);
2436 DPRI3("max_mem=%d max_grp=%d\n",
2437 max_mem, max_grp);
2438 } ELSE {
2439 max_mem = 999;
2440 max_grp = 99;
2441 }
2442 ign_action();
2443 (void) printf("N\t%d\t%d\n",
2444 max_mem, max_grp);
2445
2446 /* get groups */
2447 if (!nogroup) {
2448 while(GetGroup());
2449 }
2450
2451 /* get memory */
2452 while(GetMemory());
2453 }
2454
GetOneMail()2455 int GetOneMail()
2456 {
2457 int ret = 1;
2458 int len;
2459 int num;
2460
2461 /* request mail data */
2462 VaSendHex(0x14, EOL);
2463
2464 /* 0x15:read memory, 0x18:data end */
2465 RcvBuf(1);
2466
2467 if (buf[0] == 0x15) {
2468 /* read memory */
2469
2470 (void) printf("M\t");
2471
2472 /* 00 00 */
2473 num = RcvNumber();
2474 (void) printf("%d\t0\t0\t",num);
2475 DOUT((stderr,"number:%d\n", num));
2476 MSG((stderr,"getting memory #%d\n",num));
2477
2478 /* kana */
2479 len = RcvByte();
2480 if (len) {
2481 RcvStr(len, buf);
2482 (void) printf("%s\t",buf);
2483 DOUT((stderr,"kana:%s\n", buf));
2484 } else {
2485 (void) printf("???\t");
2486 }
2487
2488 /* kanji */
2489 len = RcvByte();
2490 if (len) {
2491 RcvStr(len, buf);
2492 (void) printf("%s\t",buf);
2493 DOUT((stderr,"kanji:%s\n", buf));
2494 } else {
2495 (void) printf("???\t");
2496 }
2497
2498 /* address */
2499 len = RcvByte();
2500 if (len) {
2501 RcvStr(len, buf);
2502 (void) printf("000\t%s",buf);
2503 DOUT((stderr,"address:%s\n", buf));
2504 } else {
2505 (void) printf("000\t???");
2506 }
2507 (void) printf("\n");
2508 /* 00 00 00 00 00 00 */
2509 RcvBuf(6);
2510 /* check sum */
2511 RcvBuf(2);
2512 /* 00 00 */
2513 RcvBuf(2);
2514 } else {
2515 ret = 0;
2516 }
2517
2518 return ret;
2519 }
2520
read_mail_spool()2521 void read_mail_spool()
2522 {
2523 char dummy[256];
2524 int col, even;
2525 int len;
2526 int num;
2527 int email01, email02;
2528 int priority, privacy, haisin_verify;
2529 int pin, polling;
2530 int year, month, day, hour, min, temp;
2531
2532 DOUT((stderr, "\nread_mail_spool()\n"));
2533
2534 reset_mail_sum();
2535
2536 /* 00 03 0b 00 04 00 01(mail start) */
2537 RcvBuf(7);
2538 num = RcvNumber();
2539 DOUT((stderr,"mail number=%d\n", num));
2540
2541 /* from number */
2542 col = RcvShort();
2543
2544 /* 00 09(number start) */
2545 RcvBuf(2);
2546
2547 even = col%2;
2548 RcvSwapNum(dummy, col/2+1+even, even);
2549
2550 DOUT((stderr, "from phone=%s\n", dummy));
2551
2552 /* skip dummy ff */
2553 RcvBuf(20 - (col + even));
2554
2555
2556 /* to number */
2557 col = RcvShort();
2558
2559 /* 00 09(cellular) 09 03(email)*/
2560 RcvBuf(2);
2561
2562 even = col%2;
2563 RcvSwapNum(dummy, col/2+1+even, even);
2564
2565 DOUT((stderr, "to phone=%s\n", dummy));
2566
2567 /* skip dummy ff */
2568 RcvBuf(20 - (col + even));
2569
2570 /* skip to mail body */
2571 DOUT((stderr, "skip to mail body\n"));
2572 RcvBuf(4);
2573
2574 /* 0x61:sokutatu, 0x21:normal */
2575 priority = RcvByte();
2576 DOUT((stderr, "priority = %s\n", (priority == 0x61)?"sokutatu":"normal"));
2577
2578 /* 00 09: skymail , 00 0a: email */
2579 email01 = RcvByte();
2580 DOUT((stderr, "email?=%d\n", (email01 == 0x0a)?"email":"sky mail"));
2581
2582 /* 1:verify 0:no verify */
2583 haisin_verify = RcvByte();
2584 DOUT((stderr, "haisin_verify=%d\n", haisin_verify));
2585
2586 /* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 */
2587 RcvBuf(24);
2588
2589 /* 1: not polling 2: polling */
2590 polling = RcvByte();
2591 DOUT((stderr, "polling=%d\n", polling));
2592
2593 /* privacy level:1-4 */
2594 privacy = RcvByte();
2595 DOUT((stderr, "privacy=%d\n", privacy));
2596
2597 pin = rcv_half()*1000 + rcv_half()*100 + rcv_half()*10 + rcv_half();
2598 DOUT((stderr, "pin=%d\n", pin));
2599
2600 /* 00 00 0f 0f 0f 0f 0f 0f */
2601 RcvBuf(8);
2602
2603 /* 3f:sky mail 12:email */
2604 email02 = RcvByte();
2605 DOUT((stderr, "email?=%d\n", (email02 == 0x12)?"email":"sky mail"));
2606
2607 /* 00 00 00 00 00 00 00 00 00 00 */
2608 RcvBuf(10);
2609
2610 DOUT((stderr,"sum=%x\n", mail_sum - 0xb3));
2611 RcvBuf(2);
2612
2613 len = RcvByte();
2614 /* dummy 00 00 */
2615 RcvBuf(2);
2616 RcvStr(len-1, dummy);
2617 dummy[len] = 0;
2618 DOUT((stderr, "mail:%s\n", dummy));
2619
2620 /* date */
2621 year = rcv_digit();
2622 month = rcv_digit();
2623 day = rcv_digit();
2624 hour = rcv_digit();
2625 min = rcv_digit();
2626
2627 DOUT((stderr,"date: %02d/%02d/%02d %02d:%02d\n",
2628 year, month, day, hour, min));
2629
2630 /* 00 00 00 09 00 00 */
2631 RcvBuf(6);
2632
2633 temp = rcv_digit();
2634 DOUT((stderr,"temp=%02d\n", temp));
2635 }
2636
read_sms_group()2637 void read_sms_group()
2638 {
2639 int num, len, sum;
2640
2641 /* 00 00 01 */
2642 RcvBuf(1);
2643 num = RcvByte();
2644 /* 00 00 */
2645 RcvBuf(2);
2646 len = RcvByte();
2647 if (len) {
2648 RcvStr(len, buf);
2649 DOUT((stderr,"group name:%s\n", buf));
2650 }
2651 sum = RcvByte();
2652
2653 DOUT((stderr,"mail group:%d\n", num));
2654 }
2655
ReadMail(passwd)2656 void ReadMail(passwd)
2657 char *passwd;
2658 {
2659 int x;
2660
2661 /* rcv: 30 */
2662 RcvBuf(1);
2663
2664 VaSendHex(0x24, EOL);
2665
2666 /* 25: mail group */
2667 RcvBuf(1);
2668 while(buf[0] == 0x25) {
2669 if (buf[0] == 0x25) {
2670 /* J-T03 mail group data */
2671 read_sms_group();
2672 }
2673
2674 VaSendHex(0x24, EOL);
2675 RcvBuf(1);
2676 }
2677
2678 /* rcv: 18 (separator: email addressed) */
2679
2680 while(GetOneMail());
2681
2682
2683 /* request mail spool */
2684 DOUT((stderr, "request mail spool\n"));
2685 VaSendHex(0x16, EOL);
2686
2687 /* rcv 17: mail spool
2688 * 18: abort
2689 */
2690 RcvBuf(1);
2691 while (buf[0] == 0x17) {
2692 read_mail_spool();
2693 /* request mail spool */
2694 VaSendHex(0x16, EOL);
2695 RcvBuf(1);
2696 }
2697
2698 VaSendHex(0x1b, EOL);
2699 RcvBuf(1);
2700
2701 VaSendHex(0x1d, EOL);
2702 RcvBuf(1);
2703
2704 /* polling data */
2705 DOUT((stderr, "\nrequest polling data.\n"));
2706 VaSendHex(0x1f, EOL);
2707 #if 0
2708 RcvBuf(60);
2709
2710 VaSendHex(0x18, EOL);
2711 RcvBuf(0);
2712
2713 VaSendHex(0x28, EOL);
2714
2715 RcvBuf(0);
2716 #endif
2717 }
2718
calc_sum(str)2719 UCHAR calc_sum(str)
2720 UCHAR *str;
2721 {
2722 UCHAR *p = str;
2723 int sum = 0;
2724 int temp;
2725
2726 while(*p){
2727 sum += *p;
2728 p++;
2729 }
2730
2731 temp = sum % 256;
2732
2733 return (UCHAR) temp;
2734 }
2735
send_one_mail_addr(num,yomi,kanji,email)2736 void send_one_mail_addr(num, yomi, kanji, email)
2737 int num;
2738 UCHAR *yomi, *kanji, *email;
2739 {
2740 UCHAR sum;
2741
2742 MSG((stderr, "sending email data #%d\n", num));
2743
2744 /* request mail data */
2745 /* rcv 14 */
2746 RcvBuf(1);
2747
2748 /* send memory start */
2749 VaSendHex(0x15, EOL);
2750
2751 /* 00 00 */
2752 SendNumber(num);
2753
2754 if (*yomi) {
2755 DPRI3("yomi_len=%d len=%d\n", yomi_len, strlen(yomi));
2756 if (yomi_len && (strlen(yomi)>yomi_len)) {
2757 SendStrN(yomi,yomi_len);
2758 } else {
2759 SendStr(yomi);
2760 }
2761 } else {
2762 VaSendHex(0x00, 0x00, EOL);
2763 }
2764
2765 if (*kanji) {
2766 if (kanji_len && (strlen(kanji) > kanji_len)) {
2767 SendStrN(kanji, kanji_len);
2768 } else {
2769 SendStr(kanji);
2770 }
2771 } else {
2772 VaSendHex(0x00, 0x00, EOL);
2773 }
2774
2775 SendStr(email);
2776
2777 VaSendHex( 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, EOL);
2778
2779 sum = calc_sum(email);
2780
2781 SendChar(sum);
2782
2783 VaSendHex(0x00, 0x00, EOL);
2784 }
2785
WriteMail()2786 void WriteMail()
2787 {
2788 int x;
2789 int i;
2790
2791 VaSendHex(0x30, EOL);
2792
2793 /* rcv 24 */
2794 RcvBuf(1);
2795
2796 #if 0
2797 /* J-T03 mail group data */
2798 /* 25 */
2799 VaSendHex(0x25, EOL);
2800 /* 00 00 01 00 00 00 00 00 00 */
2801 VaSendHex(0x00, 0x00, 0x01, 0x00, 0x00,
2802 0x00, 0x06,
2803 0x08, 0x02, 0x0b, 0x00, 0x08, 0x02, 0x0e, 0x09, 0x08, 0x02, 0x05, 0x00,
2804 0x06, 0x0f, EOL);
2805 /* Rcv: 24 */
2806 RcvBuf(1);
2807 RcvBuf(0);
2808 #endif
2809
2810 /* email */
2811 VaSendHex(0x18, EOL);
2812
2813 /* send name & address data */
2814 for(i=0; i<read_mem_num; i++){
2815 if (file_mem_email[i][0]){
2816 DOUT((stderr, "i=%d[%c]\n", i, file_mem_email[i][0]));
2817 send_one_mail_addr(file_mem_num[i],file_mem_yomi[i],
2818 file_mem_kanji[i], file_mem_email[i]);
2819 }
2820 }
2821
2822 /* rcv 14 */
2823 RcvBuf(1);
2824
2825 /* end email address */
2826 VaSendHex(0x18,EOL);
2827
2828 /* rcv 16: mail spool request */
2829 RcvBuf(1);
2830
2831 /* do not send mail spool */
2832 /*
2833 VaSendHex(0x17,EOL);
2834 VaSendHex(0x00, 0x03, 0x0b, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x09, 0x09, 0x0a, 0x01, 0x0a, 0x05, 0x07, 0x07, 0x03, 0x0a, 0x0a, 0x0a, 0x09, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x05, 0x00, 0x09, 0x02, 0x01, 0x04, 0x03, 0x09, 0x05, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x02, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x03, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x09, 0x00, 0x07, 0x00, 0x00, 0x08, 0x02, 0x0a, 0x00, 0x08, 0x02, 0x0d, 0x09, 0x08, 0x02, 0x0c, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x0d, 0x0a, EOL);
2835 */
2836
2837
2838 VaSendHex(0x18,EOL);
2839
2840 /* rcv 1b */
2841 RcvBuf(1);
2842 VaSendHex(0x18, EOL);
2843
2844 /* rcv 1d */
2845 RcvBuf(1);
2846 VaSendHex(0x18, EOL);
2847
2848 /* rcv 1f: send polling data */
2849 RcvBuf(1);
2850 VaSendHex(0x20, 0x00, 0x00, 0x08, 0x08, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x00, 0x00, 0x09, 0x06, 0x01, 0x01, 0x00, 0x00, 0x08, 0x0c, 0x06, 0x06, 0x08, 0x0e, 0x0a, 0x06, 0x09, 0x04, 0x0c, 0x02, 0x00, 0x0e, 0x04, 0x03, 0x05, 0x0e, 0x03, 0x00, 0x04, 0x00, 0x00, 0x0f, 0x08, 0x02, 0x0c, 0x08, 0x08, 0x02, 0x0b, 0x05, 0x03, 0x0c, EOL);
2851
2852 /* rcv 18 */
2853 RcvBuf(1);
2854 }
2855
sms_init()2856 void sms_init()
2857 {
2858 int x;
2859
2860 establish_connection();
2861
2862 ALARMW {
2863 RcvMsgMask(1,0xa3,0x7f);
2864 }
2865
2866 sleep(2);
2867
2868 /* send: break; 6c 07 */
2869 VaSendHex(0x6c, 0x07, EOL);
2870
2871 (void) fprintf(stderr, "push cellular for SMS transfer.\n");
2872
2873 /* wait 1c 0e 0c 0d */
2874 VaWait(4, 0x1c, 0x0e, 0x0c, 0x0d, EOL);
2875
2876 VaSendHex(0x1c, 0x0e, 0x0c, 0x0d, EOL);
2877
2878 /* baud rate */
2879 RcvBufVerify(2,0x25);
2880 x = buf[1];
2881 VaSendHex(0x25, x, EOL);
2882 change_baud_code(x);
2883
2884 sleep(1);
2885
2886 (void) fprintf(stderr, "enter passcode on cellular\n");
2887 /* rcv passcode(07) : 10 9a 9a 9a 9a aa */
2888 /* (0f): 90 9b 1b */
2889 RcvBuf(6);
2890
2891 /* cellular info */
2892 /*
2893 VaSendHex(0x11, 0x13, 0x00, 0x02, 0x05, 0x00, 0x00, 0x01, 0x04, 0x01, 0x04, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0x02, 0x03, 0x00, 0x00, 0x00, 0x08, EOL);
2894 */
2895 /* J-D03 */
2896 VaSendHex(0x11, 0x13, 0x00, 0x02, 0x0a, 0x00, 0x00, 0x01, 0x08, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x06, 0x03, 0x0f, 0x06, 0x03, 0x00, 0x07, EOL);
2897
2898 SendStrNoLen(ID_CELRW);
2899 send_hexs("09 09 09 09 09 09");
2900
2901 VaSendHex(0x00, 0x00, 0x03, 0x0a, EOL);
2902
2903 /* rcv 13...0a */
2904 RcvBuf(24);
2905 RcvStr(6, dummy);
2906 RcvBuf(4);
2907 DPRI2("remote id=[%s]\n",
2908 dummy);
2909 RcvBuf(4);
2910 }
2911
2912
force_sms_init(passwd)2913 void force_sms_init(passwd)
2914 {
2915 int x;
2916
2917 establish_connection();
2918
2919 ALARMW {
2920 RcvMsgMask(1,0xa3,0x7f);
2921 }
2922
2923 sleep(2);
2924
2925 /* send: break; 6c 07 */
2926 VaSendHex(0x6c, 0x07, EOL);
2927
2928
2929 VaSendHex(0x1c, 0x0e, 0x0c, 0x0d, EOL);
2930 /* wait 1c 0e 0c 0d */
2931 VaWait(4, 0x1c, 0x0e, 0x0c, 0x0d, EOL);
2932
2933 /* baud rate */
2934 VaSendHex(0x25, 0x0f, EOL);
2935 RcvBufVerify(2,0x25);
2936 x = buf[1];
2937 change_baud_code(x);
2938
2939 sleep(1);
2940
2941 /* send passcode */
2942 VaSendHex(0x10, EOL);
2943 SendStrNum(passwd);
2944 VaSendHex(0xaa, EOL);
2945
2946 /* rcv 13...0a */
2947 RcvBuf(24);
2948 RcvStr(6, dummy);
2949 RcvBuf(4);
2950 DPRI2("remote id=[%s]\n",
2951 dummy);
2952 RcvBuf(4);
2953
2954 /* cellular info */
2955 VaSendHex(0x11, 0x13, 0x00, 0x02, 0x05, 0x00, 0x00, 0x01, 0x04, 0x01, 0x04, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x03, 0x02, 0x03, 0x00, 0x00, 0x00, 0x08, EOL);
2956 SendStrNoLen(ID_CELRW);
2957 send_hexs("09 09 09 09 09 09");
2958
2959 VaSendHex(0x00, 0x00, 0x03, 0x0a, EOL);
2960
2961 }
2962
WriteMail2()2963 void WriteMail2()
2964 {
2965 sms_init();
2966
2967 WriteMail();
2968 }
2969
ReadMail2(passwd)2970 void ReadMail2(passwd)
2971 char *passwd;
2972 {
2973 force_sms_init(passwd);
2974 ReadMail();
2975 }
2976
ReadMail3(passwd)2977 void ReadMail3(passwd)
2978 char *passwd;
2979 {
2980 sms_init();
2981 ReadMail();
2982 }
2983
read_dial()2984 void read_dial()
2985 {
2986 unsigned char c = 0;
2987 unsigned char *p = str_dial;
2988
2989 DOUT((stderr, "read_dial:"));
2990 do {
2991 if (read(mfd, &c, 1) < 0) {
2992 perror("read_dial");
2993 h_signal();
2994 }
2995 if (c < 0xc0) {
2996 DOUT((stderr, "%02x ", c));
2997 if (c==0x9a) {
2998 *p++ = c - 0x6a;
2999 } else {
3000 *p++ = c - 0x60;
3001 }
3002 }
3003 } while (c != 0xaa);
3004 DOUT((stderr, "\n"));
3005 *p = 0;
3006 }
3007
establish_connection2()3008 void establish_connection2()
3009 {
3010 send_hexs("8e");
3011 sleep(1);
3012 read_dial();
3013 send_hexs("8e");
3014 sleep(1);
3015 read_dial();
3016 }
3017
kddi_display_info()3018 void kddi_display_info()
3019 {
3020 int num;
3021
3022 num = (kddi_entry[0x0b][0]<<8)+kddi_entry[0x0b][1];
3023 (void) fprintf(stdout,"M\t%d\t%d\t0\t%s\t%s\t%s\t%s\n",
3024 num,
3025 kddi_entry[10][1],kddi_entry[2],kddi_entry[1],
3026 kddi_entry[3],kddi_entry[5]);
3027 }
3028
kddi_read_cluster()3029 void kddi_read_cluster()
3030 {
3031 rcv_buf(2,0); // 01 80
3032 kddi_buf_size = RcvShort();
3033 DOUT((stderr,"kddi_buf_size=%d\n", kddi_buf_size));
3034 rcv_buf(kddi_buf_size,0); // 02
3035 kddi_ptr = 1;
3036 }
3037
kddi_buf()3038 unsigned char kddi_buf()
3039 {
3040 unsigned char ret;
3041
3042 ret = buf[kddi_ptr++];
3043 if (kddi_ptr >= kddi_buf_size-3) {
3044 send_hexs("06");
3045 if (buf[kddi_ptr] == 0x03) {
3046 kddi_buf_size = 0;
3047 } else {
3048 kddi_read_cluster();
3049 }
3050 }
3051
3052 return ret;
3053 }
3054
kddi_cmd_begin()3055 void kddi_cmd_begin()
3056 {
3057 cksum = 0;
3058 send_hexs("01 00");
3059 }
3060
kddi_bin_begin()3061 void kddi_bin_begin()
3062 {
3063 send_hexs("02");
3064 }
3065
kddi_bin_end()3066 void kddi_bin_end()
3067 {
3068 send_hexs("03");
3069 }
3070
kddi_change_baud(b)3071 void kddi_change_baud(b)
3072 int b;
3073 {
3074 kddi_cmd_begin();
3075 send_short(10);
3076 kddi_bin_begin();
3077 send_hexs("00 01"); // specify baud rate
3078 send_long(b);
3079 kddi_bin_end();
3080 rev_cksum();
3081 }
3082
kddi_negociate_baud_rate()3083 void kddi_negociate_baud_rate()
3084 {
3085 int i = NUM_BAUD-1;
3086
3087 do {
3088 kddi_change_baud(valid_baud[i]);
3089 rcv_buf(1,IGNORE_CF); // 06
3090 if (buf[0] == 0x06) {
3091 change_baud_code(valid_baud[i]);
3092 break;
3093 }
3094 i--;
3095 } while (i>=0);
3096
3097 if (i<0) {
3098 (void) fprintf(stderr,"cant set baud rate.\n");
3099 h_signal();
3100 }
3101 }
3102
kddi_bin_connection(passwd)3103 void kddi_bin_connection(passwd)
3104 char *passwd;
3105 {
3106 int num;
3107 int temp_mem = 999, temp_grp = 99;
3108 int frame_size;
3109
3110 establish_connection2();
3111
3112 send_hexs("b3 0e 02");
3113 rcv_buf(3, IGNORE_CF); // 6c 0e 02
3114
3115 SendMaxGroup(0xb3, temp_mem, temp_grp);
3116 GetMaxNum(0x6c, &temp_mem, &temp_grp);
3117
3118 send_hexs("d0 01 05");
3119 rcv_buf(3, IGNORE_CF); // d0 01 06
3120
3121 sleep(1);
3122
3123 send_hexs("05");
3124 rcv_buf(1,IGNORE_CF); // 06
3125 // 00 00: SetProtocolVersion
3126 // 00 01 00 00: protol version = 010000h
3127 send_hexs("01 00 00 0a 02 00 00 00 01 00 00 03 ff ee");
3128 rcv_buf(1,IGNORE_CF); // 06
3129
3130 frame_size = 0x00001000;
3131 do {
3132 cksum = 0;
3133 kddi_cmd_begin();
3134 send_short(10);
3135 kddi_bin_begin();
3136 send_hexs("00 03"); // SetFrameSize
3137 send_long(frame_size);
3138 send_hexs("03");
3139 rev_cksum();
3140
3141 rcv_buf(1,IGNORE_CF); // 06
3142
3143 frame_size /= 2;
3144 } while (buf[0] != 0x06);
3145
3146 kddi_negociate_baud_rate();
3147
3148 sleep(1);
3149
3150 // 02 04: GetProfile , 00 00 Generic Profile
3151 send_hexs("01 00 00 08 02 02 04 00 00 03 ff eb");
3152 rcv_buf(1,IGNORE_CF); // 06
3153
3154 rcv_buf(2,0); // 01 80
3155 num = RcvShort(); // 00 40
3156 rcv_buf(num, 0);
3157
3158 send_hexs("06");
3159
3160 // 02 04: GetProfile , 01 00 Extended Profile
3161 send_hexs("01 00 00 08 02 02 04 01 00 03 ff ea");
3162
3163 rcv_buf(1,IGNORE_CF); // 06
3164 rcv_buf(2,0); // 01 80
3165 num = RcvShort(); // 00 4a
3166 rcv_buf(num, 0);
3167
3168 send_hexs("06");
3169
3170 // authorize password
3171 sum_mode = SUM_BYTE;
3172 cksum = 0;
3173 send_hexs("01 00 00 0a 02 00 21"); // 00 21:SetLockNo
3174 send_raw_str(passwd);
3175 send_hexs("03");
3176 rev_cksum();
3177
3178 rcv_buf(1,IGNORE_CF); // 06
3179 }
3180
kddi_bin_read(passwd)3181 void kddi_bin_read(passwd)
3182 char *passwd;
3183 {
3184 int x;
3185 unsigned char next;
3186 int i,num;
3187 unsigned char *q, c;
3188 unsigned char cmd;
3189 int stored;
3190
3191 kddi_bin_connection(passwd);
3192
3193 // get memory
3194 send_hexs("01 00 00 0a 02 02 20 01 03 00 00 03 ff c9");
3195 do {
3196 rcv_buf(1,IGNORE_CF); // 06
3197 } while(buf[0] != 0x06);
3198
3199 stored = 0;
3200
3201 kddi_read_cluster();
3202 do {
3203 c = kddi_buf();
3204
3205 switch (c) {
3206 case 0x1c: // line start
3207 if (stored) {
3208 kddi_display_info();
3209 }
3210 for(i=0; i<KDDI_ENTRY_NUM; i++){
3211 kddi_entry[i][0] = 0;
3212 }
3213 stored = 0;
3214 break;
3215
3216 case 0x1e: // entry start
3217 /*
3218 * 01: kanji
3219 * 02: kana
3220 * 03: phone number
3221 * 04: 0x10
3222 * 05: email
3223 * 06: 0x17
3224 * 07: 0x01
3225 * 0a: group
3226 * 0b: number
3227 * 10: date
3228 */
3229 cmd = kddi_buf();
3230 switch (cmd) {
3231 case 0x01:
3232 case 0x02:
3233 case 0x03:
3234 case 0x05:
3235 case 0x0a:
3236 stored = 1;
3237 break;
3238 }
3239 num = (kddi_buf()<<8) + kddi_buf();
3240 kddi_entry[cmd][num] = 0;
3241 q = kddi_entry[cmd];
3242 for(i=0; i<num; i++){
3243 *q++ = kddi_buf();
3244 }
3245 if (cmd == 0x0b) {
3246 num = (kddi_entry[0x0b][0]<<8)+kddi_entry[0x0b][1];
3247 MSG((stderr,"getting memory #%d\n",num));
3248 }
3249 break;
3250 }
3251 } while (kddi_buf_size);
3252
3253 if (stored) {
3254 kddi_display_info();
3255 }
3256
3257 send_hexs("04");
3258
3259 sleep(1);
3260 }
3261
kddi_send_memory()3262 int kddi_send_memory()
3263 {
3264 /* skip no_data area */
3265 while(n_mem<read_mem_num &&
3266 *file_mem_phone[n_mem] == 0) {
3267 n_mem++;
3268 }
3269
3270 if (n_mem < read_mem_num) {
3271 int bytes;
3272 // estimate data bytes
3273 bytes = 2+4+strlen(file_mem_kanji[n_mem]) +
3274 4 + strlen(file_mem_yomi[n_mem]) +
3275 4 + strlen(file_mem_phone[n_mem]) +
3276 5 +
3277 4 + strlen(file_mem_email[n_mem]) +
3278 5+5+6+6+1+2;
3279
3280 cksum = 0;
3281 send_hexs("01 80"); // data
3282
3283 send_short(bytes);
3284 send_hexs("02");
3285 send_hexs("1c");
3286
3287 send_hexs("1e 01");
3288 send_short(strlen(file_mem_kanji[n_mem]));
3289 send_raw_str(file_mem_kanji[n_mem]);
3290
3291 send_hexs("1e 02");
3292 send_short(strlen(file_mem_yomi[n_mem]));
3293 send_raw_str(file_mem_yomi[n_mem]);
3294
3295 send_hexs("1e 03");
3296 send_short(strlen(file_mem_phone[n_mem]));
3297 send_raw_str(file_mem_phone[n_mem]);
3298
3299 send_hexs("1e 04 00 01 10");
3300
3301 send_hexs("1e 05");
3302 send_short(strlen(file_mem_email[n_mem]));
3303 send_raw_str(file_mem_email[n_mem]);
3304
3305 send_hexs("1e 06 00 01 17");
3306 send_hexs("1e 07 00 01 01");
3307
3308 send_hexs("1e 0a 00 02");
3309 send_short(file_mem_grp[n_mem]);
3310
3311 send_hexs("1e 0b 00 02");
3312 send_short(file_mem_num[n_mem]);
3313
3314 n_mem++;
3315 if (n_mem < read_mem_num) {
3316 send_hexs("17");
3317 } else {
3318 send_hexs("03");
3319 }
3320 rev_cksum();
3321
3322 do {
3323 rcv_buf(1,IGNORE_CF); // 06
3324 } while (buf[0] != 0x06);
3325
3326 } else {
3327 return 1;
3328 }
3329
3330 return 0;
3331 }
3332
kddi_bin_write(passwd)3333 void kddi_bin_write(passwd)
3334 char *passwd;
3335 {
3336 int x;
3337 unsigned char next;
3338 int i,num;
3339 unsigned char *q, c;
3340 unsigned char cmd;
3341 int stored;
3342
3343 kddi_bin_connection(passwd);
3344
3345 // put memory
3346 cksum = 0;
3347 send_hexs("01 00 00 0a 02 01 20 01 03 00 00 03");
3348 rev_cksum();
3349 rcv_buf(1,IGNORE_CF); // 06
3350
3351 while(!kddi_send_memory());
3352
3353 send_hexs("04");
3354
3355 sleep(1);
3356 }
3357
send_raw_file(fsize)3358 void send_raw_file(fsize)
3359 int fsize;
3360 {
3361 FILE *fp;
3362 unsigned char c, *p;
3363 int size;
3364 unsigned int a;
3365 int i;
3366
3367 // send each 01fc bytes
3368 // 02:start, 17:continue, 03:last
3369 if ((fp = fopen(binary_fname,"r")) == NULL){
3370 (void) fprintf(stderr,"Can't open [%s].\n", binary_fname);
3371 exit(1);
3372 }
3373
3374 while (fsize) {
3375 size = fread(buf,1,0x01fc-4,fp);
3376 fsize -= size;
3377
3378 cksum=0;
3379 send_hexs("01 80");
3380
3381 a = size + 4;
3382 SendHex(a>>8);
3383 SendHex(a&0xff);
3384 cksum += (a>>8) + (a&0xff);
3385
3386 send_hexs("02");
3387 p = buf;
3388 for(i=0; i<size; i++){
3389 SendHex(*p);
3390 cksum += *p;
3391 p++;
3392 }
3393
3394 if (size == 0x01fc-4) {
3395 send_hexs("17");
3396 } else {
3397 send_hexs("03");
3398 }
3399 rev_cksum();
3400
3401 do {
3402 rcv_buf(1,IGNORE_CF); // TUKA 07 06, AU 06
3403 } while(buf[0] != 0x06);
3404 }
3405
3406 (void) fclose(fp);
3407 }
3408
kddi_file(passwd)3409 void kddi_file(passwd)
3410 char *passwd;
3411 {
3412 int x;
3413 unsigned char next, *p;
3414 unsigned int a;
3415 unsigned char c;
3416 int num;
3417 int size;
3418
3419 kddi_bin_connection(passwd);
3420
3421 // filename
3422 p = strrchr(binary_fname, '/');
3423 if (!p) {
3424 p = binary_fname;
3425 } else {
3426 p++;
3427 }
3428 size = strlen(p) + 3+3+2+1+2;
3429 cksum=0;
3430 kddi_cmd_begin();
3431 send_short(size);
3432 kddi_bin_begin();
3433 send_hexs("01 10"); // PutFile
3434 send_raw_str(p);
3435
3436 size = get_file_size();
3437 send_hexs("00");
3438 send_long(size);
3439
3440 kddi_bin_end();
3441 rev_cksum();
3442
3443 rcv_buf(1,IGNORE_CF); // 06
3444
3445 // file
3446 send_raw_file(size);
3447
3448 send_hexs("04");
3449
3450 sleep(1);
3451 }
3452
voda_send_binary_file()3453 void voda_send_binary_file()
3454 {
3455 FILE *fp;
3456 unsigned char c;
3457 int size;
3458
3459 if ((fp = fopen(binary_fname,"r")) == NULL){
3460 (void) fprintf(stderr,"Can't open [%s].\n", binary_fname);
3461 exit(1);
3462 }
3463
3464 do {
3465 size = fread(&c,1,1,fp);
3466 if (size>0) {
3467 SendChar(c);
3468 cksum += c;
3469 }
3470 } while(!feof(fp));
3471
3472 (void) fclose(fp);
3473 }
3474
voda_file(passwd)3475 void voda_file(passwd)
3476 char *passwd;
3477 {
3478 int x;
3479 unsigned char next, *p, *q, *r;
3480 int temp_mem = 999, temp_grp = 99;
3481 time_t t;
3482 unsigned int a;
3483 unsigned char c;
3484
3485 establish_connection2();
3486
3487 send_hexs("b3 0e 02");
3488 rcv_buf(3, IGNORE_CF); // 6c 0e 02
3489
3490 SendMaxGroup(0xb3, temp_mem, temp_grp);
3491 GetMaxNum(0x6c, &temp_mem, &temp_grp);
3492
3493 send_hexs("1c 0e 0e 0d");
3494 rcv_buf(4, IGNORE_CF); // 1c 0e 0e 0d
3495
3496 sleep(1);
3497
3498 send_hexs("25 0f");
3499 do {
3500 rcv_buf(1,IGNORE_CF); // 25 03
3501 } while (buf[0] != 0x25);
3502
3503 rcv_buf(1,IGNORE_CF);
3504 switch (buf[0]) {
3505 case 3:
3506 DOUT((stderr, "change baud to 9600\n"));
3507 change_baud(B9600);
3508 break;
3509 case 7:
3510 DOUT((stderr, "change baud to 19200\n"));
3511 change_baud(B19200);
3512 break;
3513 case 0x0f:
3514 DOUT((stderr, "change baud to 38400\n"));
3515 change_baud(B38400);
3516 break;
3517 default:
3518 (void) fprintf(stderr, "unsupported baud code [%02x]\n", buf[0]);
3519 break;
3520 }
3521
3522 sleep(1);
3523
3524 // authorize password
3525 send_hexs("10");
3526 SendStrNum(passwd);
3527 send_hexs("aa");
3528
3529 rcv_buf(1,IGNORE_CF); // 51=success, 30=fail
3530 if (buf[0] != 0x51) {
3531 MSG((stderr, "invalid password\n"));
3532 h_signal();
3533 }
3534
3535 // filename
3536 p = strrchr(binary_fname, '/');
3537 if (!p) {
3538 p = binary_fname;
3539 } else {
3540 p++;
3541 }
3542
3543 // filetype
3544 q = strrchr(binary_fname, '.');
3545 if (!p) {
3546 q = "mmf";
3547 } else {
3548 q++;
3549 }
3550
3551 // mail body
3552 send_hexs("53");
3553 cksum = 0;
3554 sum_mode = SUM_STR;
3555 SendStrNoLen("LMLSUB\r\n");
3556 SendStrNoLen("VER:2\r\n");
3557 SendStrNoLen("ADD:hoge\r\n");
3558 SendStrNoLen("FWD:L\r\n");
3559 SendStrNoLen("DTID:MS\r\n");
3560 if (!strcmp(q, "mmf")) {
3561 r = "application/x-smaf";
3562 } else if (!strcmp(q, "smd")) {
3563 r = "audio/smd";
3564 } else if (!strcmp(q, "jpg")) {
3565 r = "image/jpeg";
3566 } else if (!strcmp(q, "png")) {
3567 r = "image/png";
3568 } else {
3569 (void) fprintf(stderr,"Unsupported file type.\n");
3570 exit(-1);
3571 }
3572 SendStrNoLen("CNT:");
3573 SendStrNoLen(r);
3574 SendStrNoLen(";name=\"");
3575 SendStrNoLen(p);
3576 SendStrNoLen("\"\r\n");
3577
3578
3579 SendStrNoLen("TO:");
3580 SendStrNoLen(p);
3581 SendStrNoLen("\r\n");
3582
3583 SendStrNoLen("DATE:");
3584 t = time(NULL);
3585 strcpy(buf, ctime(&t));
3586 buf[strlen(buf)-1]=0;
3587 SendStrNoLen(buf);
3588 SendStrNoLen("\r\n");
3589
3590 SendStrNoLen("SUBJ:");
3591 SendStrNoLen(p);
3592 SendStrNoLen("\r\n");
3593
3594 SendStrNoLen("\r\n");
3595 DOUT((stderr,"sending binary file\n"));
3596 voda_send_binary_file();
3597 DOUT((stderr,"send binary file end\n"));
3598 SendStrNoLen("\r\n");
3599 SendStrNoLen(".\r\n");
3600 DOUT((stderr,"\nsum=%x\n", cksum));
3601 a = cksum & 0xff;
3602 SendChar((unsigned char) a);
3603 send_hexs("15");
3604
3605 DOUT((stderr,"Result:\n"));
3606 rcv_buf(1,IGNORE_CF); // 53
3607
3608 c=0;
3609 a = 0;
3610 do {
3611 if (read(mfd, &c, 1) < 0) {
3612 perror("voda_file");
3613 h_signal();
3614 }
3615 if (c<0x10){
3616 if (!a) {
3617 x = c<<4;
3618 } else {
3619 x += c;
3620 DOUT((stderr,"%c", x));
3621 }
3622 a = 1-a;
3623 } else {
3624 DOUT((stderr,"%02x ",c));
3625 }
3626 } while (c != 0x15);
3627 DOUT((stderr,"\n"));
3628
3629 send_hexs("1c 02 08 0d");
3630 rcv_buf(4,IGNORE_CF); //CEL:1c 02 08 0d
3631 }
3632
input_passwd()3633 UCHAR *input_passwd()
3634 {
3635 TERMIO sg0, sg1;
3636 int i;
3637 UCHAR c;
3638 static UCHAR b[10];
3639
3640 Tcgeta(0, &sg0);
3641 Tcgeta(0, &sg1);
3642
3643 sg1.c_lflag &= ~(ECHO|ICANON);
3644 sg1.c_lflag |= ISIG;
3645
3646 Tcseta(0, &sg1);
3647
3648 (void) fprintf(stderr,"input passwd : ");
3649 (void) fflush(stderr);
3650
3651 for(i=0; i<4; i++){
3652 c = (UCHAR) getchar();
3653 (void) fprintf(stderr,"*");
3654 (void) fflush(stderr);
3655 b[i] = c;
3656 }
3657 b[4] = '\0';
3658 (void) fprintf(stderr,"\n");
3659
3660 Tcseta(0, &sg0);
3661
3662 return(b);
3663 }
3664
ListKind()3665 void ListKind()
3666 {
3667 int i;
3668
3669 (void) fprintf(stderr,"Supported non-generic cellulars are:\n");
3670 for(i=0; i<KIND_NUM; i++){
3671 (void) fprintf(stderr,"\t%s\n",cel_kind[i].str);
3672 }
3673 }
3674
Usage(name)3675 void Usage(name)
3676 char *name;
3677 {
3678 (void) fprintf(stderr,"\n\
3679 usage:\n\
3680 %s [-w file][-b baud][-d dev][-k kind][-p][-num password][-v][-help]\n\
3681 \n\
3682 -r : read from cellular\n\
3683 -w file : write file data to cellular [default is read]\n\
3684 -vr : read vodafone mail address\n\
3685 -vw file : write vodafone mail address\n\
3686 -vw2 file : write vodafone mail address(method 2)\n\
3687 -vfile file : send file to vodafone\n\
3688 -kr : read KDDI mail address\n\
3689 -kw file : write KDDI mail address\n\
3690 -kfile file : send file to KDDI\n\
3691 -b baud : baud rate (600,2400,9600) [default:9600 bps]\n\
3692 -d dev : serial device [default: /dev/ttyS0]\n\
3693 -k kind : kind of cellular\n\
3694 -p : use default password\n\
3695 -num pw : password for cellular [NOT RECOMMEND]\n\
3696 -yomilen len : restrict yomi length\n\
3697 -kanjilen len : restrict kanji length\n\
3698 -nogroup: don't write group data\n\
3699 -v : display version\n\
3700 -V : not verbose\n\
3701 -help : display this message\n\
3702 \n\
3703 ",name);
3704
3705 ListKind();
3706 }
3707
3708
process_script(fname)3709 void process_script(fname)
3710 char *fname;
3711 {
3712 FILE *fp;
3713 int eol = 0;
3714 unsigned char *p, *q;
3715 int n, curarg, newarg;
3716
3717 if ((fp = fopen(fname,"r")) == NULL){
3718 (void) fprintf(stderr,"Can't open [%s].\n", fname);
3719 exit(1);
3720 }
3721
3722 while (!feof(fp)){
3723 (void) file_get_token(fp,0); /* command , ignore error(EOF) */
3724 if (!strcmp(buf, "ESTABLISH")) {
3725 printf("establish_connection();\n");
3726 } else if (!strcmp(buf, "msg")) {
3727 while (!file_get_token(fp,0)) {
3728 (void) printf("%s ",buf);
3729 }
3730 } else if (!strcmp(buf, "sleep")) {
3731 (void) file_get_token(fp,0);
3732 (void) sscanf(buf, "%d", &n);
3733 printf("sleep(n);%d\n",n);
3734 } else if (!strcmp(buf, "alarmrcv")) {
3735 (void) file_get_token(fp,0);
3736 n = ascii2hex(buf);
3737 printf("ALARMW {RcvMsgMask(1,n,0x7f);}%x\n",n);
3738 } else if (!strcmp(buf, "baud")) {
3739 (void) file_get_token(fp,0);
3740 (void) sscanf(buf,"%d",&n);
3741 printf("change_baud_code(n);%d\n",n);
3742 } else if (!strcmp(buf, "wait")) {
3743 curarg = 0;
3744 n = 0;
3745 p = NULL;
3746 while(!file_get_token(fp,0)) {
3747 if (n>= curarg) {
3748 newarg = curarg + ARGSIZE;
3749 q = (unsigned char *) malloc(newarg);
3750 if (p) {
3751 memcpy(q, p, curarg);
3752 free(p);
3753 }
3754 curarg = newarg;
3755 p = q;
3756 }
3757 p[n] = ascii2hex(buf);
3758 printf("%02x ",p[n]);
3759 n++;
3760 }
3761 printf("WaitHex(n, p);%d\n",n);
3762 free(p);
3763 } else if (!strcmp(buf, "R")) {
3764 (void) file_get_token(fp,0);
3765 (void) sscanf(buf,"%d",&n);
3766 printf("RcvBuf(n);%d\n",n);
3767 } else if (!strcmp(buf, "S")) {
3768 while(!file_get_token(fp,0)) {
3769 n = ascii2hex(buf);
3770 printf("SendHex(n);%02x\n",n);
3771 }
3772 } else {
3773 (void) fprintf(stderr,"unknown command [%s]\n", buf);
3774 exit (-1);
3775 }
3776 }
3777
3778 fclose(fp);
3779 }
3780
SwitchMode(mode,passwd)3781 void SwitchMode(mode,passwd)
3782 int mode;
3783 UCHAR *passwd;
3784 {
3785 switch (mode) {
3786 case MODE_WRITE:
3787 if (read_mem_num == 0) {
3788 (void) fprintf(stderr, "You must read file.\n");
3789 exit(-1);
3790 }
3791 StoreCellular();
3792 break;
3793 case MODE_READ:
3794 if (passwd == NULL) {
3795 passwd = input_passwd();
3796 }
3797 ReadCellular(passwd);
3798 break;
3799
3800 case MODE_VODA_SMS_READ:
3801 if (passwd == NULL) {
3802 passwd = input_passwd();
3803 }
3804
3805 ReadMail2(passwd);
3806
3807 break;
3808
3809 case MODE_VODA_SMS_READ2:
3810 if (passwd == NULL) {
3811 passwd = input_passwd();
3812 }
3813
3814 ReadMail3(passwd);
3815
3816 break;
3817
3818 case MODE_VODA_SMS_WRITE:
3819 WriteMail2();
3820 break;
3821
3822 case MODE_VODA_SEND_FILE:
3823 if (passwd == NULL) {
3824 passwd = input_passwd();
3825 }
3826 voda_file(passwd);
3827 break;
3828
3829 case MODE_KDDI_BIN_READ:
3830 if (passwd == NULL) {
3831 passwd = input_passwd();
3832 }
3833 kddi_bin_read(passwd);
3834 break;
3835
3836 case MODE_KDDI_BIN_WRITE:
3837 if (passwd == NULL) {
3838 passwd = input_passwd();
3839 }
3840 kddi_bin_write(passwd);
3841 break;
3842
3843 case MODE_KDDI_SEND_FILE:
3844 if (passwd == NULL) {
3845 passwd = input_passwd();
3846 }
3847 kddi_file(passwd);
3848 break;
3849
3850 case MODE_SCRIPT:
3851 process_script(passwd);
3852 break;
3853 }
3854 }
3855
3856 #ifndef EXP
3857 #define EXP
3858 #else
3859 #include "exp.c"
3860 #endif
3861
main(argc,argv)3862 int main(argc,argv)
3863 int argc;
3864 char **argv;
3865 {
3866 int mode;
3867 UCHAR *passwd = NULL;
3868 char *appname = argv[0];
3869 int i;
3870 int valid;
3871
3872 signal(SIGINT, h_signal);
3873
3874 mode = MODE_READ;
3875 baud = 9600;
3876
3877 /***** analyze command line *****/
3878 SWITCH_OPT
3879 EXP
3880 CASE_OPT("-w"){
3881 mode = MODE_WRITE;
3882 ADVANCE_OPT;
3883 read_file(CURRENT_OPT);
3884 }
3885 CASE_OPT("-r"){
3886 mode = MODE_READ;
3887 }
3888 CASE_OPT("-d"){
3889 ADVANCE_OPT;
3890 device = CURRENT_OPT;
3891 }
3892 CASE_OPT("-num"){
3893 ADVANCE_OPT;
3894 passwd = (UCHAR *) CURRENT_OPT;
3895 }
3896 CASE_OPT("-yomilen"){
3897 ADVANCE_OPT;
3898 (void) sscanf(CURRENT_OPT, "%d", &yomi_len);
3899 }
3900 CASE_OPT("-kanjilen"){
3901 ADVANCE_OPT;
3902 (void) sscanf(CURRENT_OPT, "%d", &kanji_len);
3903 }
3904 CASE_OPT("-nogroup"){
3905 ignore_group = 1;
3906 }
3907 CASE_OPT("-p"){
3908 passwd = (UCHAR *) PASSCODE;
3909 }
3910 CASE_OPT("-kanjicode"){
3911 ADVANCE_OPT;
3912 (void) sscanf(CURRENT_OPT, "%d", &kanjicode);
3913 }
3914 CASE_OPT("-k"){
3915 ADVANCE_OPT;
3916 for(i=0; i<KIND_NUM; i++){
3917 if (!strcmp(CURRENT_OPT, cel_kind[i].str)){
3918 kind = cel_kind[i].num;
3919 }
3920 }
3921 if (kind == 0) {
3922 (void) fprintf(stderr,"Unknown kind of cellular [%s].\n",
3923 CURRENT_OPT);
3924 ListKind();
3925 exit(-1);
3926 }
3927 }
3928 CASE_OPT("-b"){
3929 ADVANCE_OPT;
3930 (void) sscanf(CURRENT_OPT, "%d", &baud);
3931 force_baud = baud;
3932 valid = 0;
3933 for(i=0; i<NUM_BAUD; i++){
3934 if (valid_baud[i] == baud) {
3935 valid = 1;
3936 }
3937 }
3938 if (!valid) {
3939 (void) fprintf(stderr,"Invalid baud rate %d.\n", baud);
3940 (void) fprintf(stderr,"Valid baud rates are\n");
3941 for(i=0; i<NUM_BAUD; i++){
3942 (void) fprintf(stderr,"%d, ", valid_baud[i]);
3943 }
3944 (void) fprintf(stderr,"\n");
3945 exit(1);
3946 }
3947 }
3948 CASE_OPT("-v"){
3949 (void) fprintf(stderr,"%s version %s\n",
3950 appname,VERSION);
3951 exit(0);
3952 }
3953 CASE_OPT("-V"){
3954 verbose = 0;
3955 }
3956 CASE_OPT("-vr"){
3957 mode = MODE_VODA_SMS_READ;
3958 }
3959 CASE_OPT("-vr2"){
3960 mode = MODE_VODA_SMS_READ2;
3961 }
3962 CASE_OPT("-vw"){
3963 mode = MODE_VODA_SMS_WRITE;
3964 ADVANCE_OPT;
3965 read_file(CURRENT_OPT);
3966 }
3967 CASE_OPT("-vfile"){
3968 mode = MODE_VODA_SEND_FILE;
3969 ADVANCE_OPT;
3970 binary_fname = CURRENT_OPT;
3971 }
3972 CASE_OPT("-kr"){
3973 mode = MODE_KDDI_BIN_READ;
3974 }
3975 CASE_OPT("-kw"){
3976 mode = MODE_KDDI_BIN_WRITE;
3977 ADVANCE_OPT;
3978 read_file(CURRENT_OPT);
3979 }
3980 CASE_OPT("-kfile"){
3981 mode = MODE_KDDI_SEND_FILE;
3982 ADVANCE_OPT;
3983 binary_fname = CURRENT_OPT;
3984 }
3985 CASE_OPT("-f"){
3986 mode = MODE_SCRIPT;
3987 ADVANCE_OPT;
3988 passwd = CURRENT_OPT;
3989 }
3990 ELSE_OPT {
3991 Usage(appname);
3992 exit(1);
3993 }
3994 END_OPT;
3995
3996 OpenDevice();
3997
3998 SwitchMode(mode,passwd);
3999
4000 /* reset DoCoMo */
4001 VaSendHex (0x1f, 0x07, 0x0d, EOL);
4002
4003 CloseDevice();
4004
4005 return 0;
4006 }
4007