]> scm.dxcluster.org Git - spider.git/blob - src/client.c
3dadfc59785c3dcab353538d14e7aa4e04c85384
[spider.git] / src / client.c
1 /*
2  * C Client for the DX Spider cluster program
3  *
4  * Eventually this program will be a complete replacement
5  * for the perl version.
6  *
7  * This program provides the glue necessary to talk between
8  * an input (eg from telnet or ax25) and the perl DXSpider
9  * node.
10  *
11  * Currently, this program connects STDIN/STDOUT to the
12  * message system used by cluster.pl
13  *
14  * Copyright (c) 2000 Dirk Koopman G1TLH
15  *
16  * $Id$
17  */
18
19 #include <stdio.h>
20 #include <sys/time.h>
21 #include <sys/types.h>
22 #include <unistd.h>
23 #include <ctype.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <netdb.h>
27 #include <sys/socket.h>
28 #include <netinet/in.h>
29 #include <errno.h>
30 #include <signal.h>
31 #include <string.h>
32 #include <termios.h>
33
34 #include "sel.h"
35 #include "cmsg.h"
36 #include "debug.h"
37
38 #define TEXT 1
39 #define MSG 2
40 #define MAXBUFL 1024
41
42 #define DBUF 1
43 #define DMSG 2
44
45 typedef struct 
46 {
47         int cnum;                                       /* the connection number */
48         int sort;                                       /* the type of connection either text or msg */
49         cmsg_t *in;                                     /* current input message being built up */
50         cmsg_t *out;                            /* current output message being sent */
51         reft *inq;                                      /* input queue */
52         reft *outq;                                     /* output queue */
53         sel_t *sp;                                      /* my select fcb address */
54         int echo;                                       /* echo characters back to this cnum */
55         struct termios t;                       /* any termios associated with this cnum */
56 } fcb_t;
57
58 char *node_addr = "localhost";  /* the node tcp address */
59 int node_port = 27754;                  /* the tcp port of the node at the above address */
60 char *call;                                             /* the caller's callsign */
61 char *connsort;                                 /* the type of connection */
62 fcb_t *in;                                              /* the fcb of 'stdin' that I shall use */
63 fcb_t *node;                                    /* the fcb of the msg system */
64 char nl = '\n';                                 /* line end character */
65 char ending = 0;                                /* set this to end the program */
66 char send_Z = 1;                                /* set a Z record to the node on termination */
67 char echo = 1;                                  /* echo characters on stdout from stdin */
68
69 void terminate(int);
70
71 /*
72  * utility routines - various
73  */
74
75 void die(char *s, ...)
76 {
77         char buf[2000];
78         
79         va_list ap;
80         va_start(ap, s);
81         vsprintf(buf, s, ap);
82         va_end(ap);
83         fprintf(stderr,"%s\n", buf);
84         terminate(-1);
85 }
86
87 char *strupper(char *s)
88 {
89         char *d = malloc(strlen(s)+1);
90         char *p = d;
91         
92         if (!d)
93                 die("out of room in strupper");
94         while (*p++ = toupper(*s++)) ;
95         return d;
96 }
97
98 char *strlower(char *s)
99 {
100         char *d = malloc(strlen(s)+1);
101         char *p = d;
102         
103         if (!d)
104                 die("out of room in strlower");
105         while (*p++ = tolower(*s++)) ;
106         return d;
107 }
108
109 int eq(char *a, char *b)
110 {
111         return (strcmp(a, b) == 0);
112 }
113
114 /*
115  * higher level send and receive routines
116  */
117
118 fcb_t *fcb_new(int cnum, int sort)
119 {
120         fcb_t *f = malloc(sizeof(fcb_t));
121         if (!f)
122                 die("no room in fcb_new");
123         memset (f, 0, sizeof(fcb_t));
124         f->cnum = cnum;
125         f->sort = sort;
126         f->inq = chain_new();
127         f->outq = chain_new();
128         return f;
129 }
130
131 void send_text(fcb_t *f, char *s, int l)
132 {
133         cmsg_t *mp;
134         mp = cmsg_new(l+1, f->sort, f);
135         memcpy(mp->inp, s, l);
136         mp->inp += l;
137         *mp->inp++ = nl;
138         cmsg_send(f->outq, mp, 0);
139         f->sp->flags |= SEL_OUTPUT;
140 }
141
142 void send_msg(fcb_t *f, char let, char *s, int l)
143 {
144         cmsg_t *mp;
145         int ln;
146         int myl = strlen(call)+2+l;
147
148         mp = cmsg_new(myl+4, f->sort, f);
149         ln = htonl(myl);
150         memcpy(mp->inp, &ln, 4);
151         mp->inp += 4;
152         *mp->inp++ = let;
153         strcpy(mp->inp, call);
154         mp->inp += strlen(call);
155         *mp->inp++ = '|';
156         if (l) {
157                 memcpy(mp->inp, s, l);
158                 mp->inp += l;
159         }
160         *mp->inp = 0;
161         cmsg_send(f->outq, mp, 0);
162         f->sp->flags |= SEL_OUTPUT;
163 }
164
165 int fcb_handler(sel_t *sp, int in, int out, int err)
166 {
167         fcb_t *f = sp->fcb;
168         cmsg_t *mp, *omp;
169         
170         /* input modes */
171         if (in) {
172                 char *p, buf[MAXBUFL];
173                 int r;
174
175                 /* read what we have into a buffer */
176                 r = read(f->cnum, buf, MAXBUFL);
177                 if (r < 0) {
178                         switch (errno) {
179                         case EINTR:
180                         case EINPROGRESS:
181                         case EAGAIN:
182                                 goto lout;
183                         default:
184                                 if (f->sort == MSG)
185                                         send_Z = 0;
186                                 ending++;
187                                 return 0;
188                         }
189                 } else if (r == 0) {
190                         if (f->sort == MSG)
191                                 send_Z = 0;
192                         ending++;
193                         return 0;
194                 }
195
196                 dbgdump(DBUF, "in ->", buf, r);
197                 
198                 /* create a new message buffer if required */
199                 if (!f->in)
200                         f->in = cmsg_new(MAXBUFL, f->sort, f);
201                 mp = f->in;
202
203                 switch (f->sort) {
204                 case TEXT:
205                         p = buf;
206                         if (f->echo)
207                                 omp = cmsg_new(3*r, f->sort, f);
208                         while (r > 0 && p < &buf[r]) {
209
210                                 /* echo processing */
211                                 if (f->echo) {
212                                         switch (*p) {
213                                         case '\b':
214                                         case 0x7f:
215                                                 strcpy(omp->inp, "\b \b");
216                                                 omp->inp += strlen(omp->inp);
217                                                 break;
218                                         default:
219                                                 *omp->inp++ = *p;
220                                         }
221                                 }
222                                 
223                                 /* character processing */
224                                 switch (*p) {
225                                 case '\b':
226                                 case 0x7f:
227                                         if (mp->inp > mp->data)
228                                                 mp->inp--;
229                                         ++p;
230                                         break;
231                                 default:
232                                         if (*p == nl) {
233                                                 if (mp->inp == mp->data)
234                                                         *mp->inp++ = ' ';
235                                                 *mp->inp = 0;              /* zero terminate it, but don't include it in the length */
236                                                 dbgdump(DMSG, "QUEUE TEXT", mp->data, mp->inp-mp->data);
237                                                 cmsg_send(f->inq, mp, 0);
238                                                 f->in = mp = cmsg_new(MAXBUFL, f->sort, f);
239                                                 ++p;
240                                         } else {
241                                                 if (mp->inp < &mp->data[MAXBUFL])
242                                                         *mp->inp++ = *p++;
243                                                 else {
244                                                         mp->inp = mp->data;
245                                                 }
246                                         }
247                                 }
248                         }
249                         
250                         /* queue any echo text */
251                         if (f->echo) {
252                                 dbgdump(DMSG, "QUEUE ECHO TEXT", omp->data, omp->inp - omp->data);
253                                 cmsg_send(f->outq, omp, 0);
254                                 f->sp->flags |= SEL_OUTPUT;
255                         }
256                         
257                         break;
258
259                 case MSG:
260                         p = buf;
261                         while (r > 0 && p < &buf[r]) {
262
263                                 /* build up the size into the likely message length (yes I know it's a short) */
264                                 switch (mp->state) {
265                                 case 0:
266                                 case 1:
267                                         mp->state++;
268                                         break;
269                                 case 2:
270                                 case 3:
271                                         mp->size = (mp->size << 8) | (*p++ & 0xff);
272                                         mp->state++;
273                                         break;
274                                 default:
275                                         if (mp->inp - mp->data < mp->size) {
276                                                 *mp->inp++ = *p++;
277                                         } 
278                                         if (mp->inp - mp->data >= mp->size) {
279                                                 /* kick it upstairs */
280                                                 dbgdump(DMSG, "QUEUE MSG", mp->data, mp->inp - mp->data);
281                                                 cmsg_send(f->inq, mp, 0);
282                                                 mp = f->in = cmsg_new(MAXBUFL, f->sort, f);
283                                         }
284                                 }
285                         }
286                         break;
287                         
288                 default:
289                         die("invalid sort (%d) in input handler", f->sort);
290                 }
291         }
292         
293         /* output modes */
294 lout:;
295         if (out) {
296                 int l, r;
297                 
298                 if (!f->out) {
299                         mp = f->out = cmsg_next(f->outq);
300                         if (!mp) {
301                                 sp->flags &= ~SEL_OUTPUT;
302                                 return 0;
303                         }
304                         mp->inp = mp->data;
305                 }
306                 l = mp->size - (mp->inp - mp->data);
307                 if (l > 0) {
308                         
309                         dbgdump(DBUF, "<-out", mp->inp, l);
310                         
311                         r = write(f->cnum, mp->inp, l);
312                         if (r < 0) {
313                                 switch (errno) {
314                                 case EINTR:
315                                 case EINPROGRESS:
316                                 case EAGAIN:
317                                         goto lend;
318                                 default:
319                                         if (f->sort == MSG)
320                                                 send_Z = 0;
321                                         ending++;
322                                         return;
323                                 }
324                         } else if (r > 0) {
325                                 mp->inp += r;
326                         }
327                 } else if (l < 0) 
328                         die("got negative length in handler on node");
329                 if (mp->inp - mp->data >= mp->size) {
330                         cmsg_callback(mp, 0);
331                         f->out = 0;
332 /*                      if (is_chain_empty(f->outq))
333                         sp->flags &= ~SEL_OUTPUT; */
334                 }
335         }
336 lend:;
337         return 0;
338 }
339
340 /*
341  * things to do with initialisation
342  */
343
344 void initargs(int argc, char *argv[])
345 {
346         int i, c, err = 0;
347
348         while ((c = getopt(argc, argv, "x:")) > 0) {
349                 switch (c) {
350                 case 'x':
351                         dbginit("client");
352                         dbgset(atoi(optarg));
353                         break;
354                 default:
355                         ++err;
356                         goto lerr;
357                 }
358         }
359
360 lerr:
361         if (err) {
362                 die("usage: client [-x nn] <call>|login [local|telnet|ax25]");
363         }
364         
365         if (optind < argc) {
366                 call = strupper(argv[optind]);
367                 if (eq(call, "LOGIN"))
368                         die("login not implemented (yet)");
369                 ++optind;
370         }
371         if (!call)
372                 die("Must have at least a callsign (for now)");
373
374         if (optind < argc) {
375                 connsort = strlower(argv[optind]);
376                 if (eq(connsort, "telnet") || eq(connsort, "local")) {
377                         nl = '\n';
378                         echo = 1;
379                 } else if (eq(connsort, "ax25")) {
380                         nl = '\r';
381                         echo = 0;
382                 } else {
383                         die("2nd argument must be \"telnet\" or \"ax25\" or \"local\"");
384                 }
385         } else {
386                 connsort = "local";
387                 nl = '\n';
388                 echo = 1;
389         }
390 }
391
392 void connect_to_node()
393 {
394         struct hostent *hp, *gethostbyname();
395         struct sockaddr_in server;
396         int nodef;
397         sel_t *sp;
398                                 
399         if ((hp = gethostbyname(node_addr)) == 0) 
400                 die("Unknown host tcp host %s for printer", node_addr);
401
402         memset(&server, 0, sizeof server);
403         server.sin_family = AF_INET;
404         memcpy(&server.sin_addr, hp->h_addr, hp->h_length);
405         server.sin_port = htons(node_port);
406                                                 
407         nodef = socket(AF_INET, SOCK_STREAM, 0);
408         if (nodef < 0) 
409                 die("Can't open socket to %s port %d (%d)", node_addr, node_port, errno);
410
411         if (connect(nodef, (struct sockaddr *) &server, sizeof server) < 0) {
412                 die("Error on connect to %s port %d (%d)", node_addr, node_port, errno);
413         }
414         node = fcb_new(nodef, MSG);
415         node->sp = sel_open(nodef, node, "Msg System", fcb_handler, MSG, SEL_INPUT);
416         
417 }
418
419 /*
420  * things to do with going away
421  */
422
423 void term_timeout(int i)
424 {
425         /* none of this is going to be reused so don't bother cleaning up properly */
426         if (in)
427                 tcsetattr(0, TCSANOW, &in->t);
428         if (node) {
429                 close(node->cnum);
430         }
431         exit(i);
432 }
433
434 void terminate(int i)
435 {
436         if (send_Z && call) {
437                 send_msg(node, 'Z', "", 0);
438         }
439         
440         signal(SIGALRM, term_timeout);
441         alarm(10);
442         
443         while ((in && !is_chain_empty(in->outq)) ||
444                    (node && !is_chain_empty(node->outq))) {
445                 sel_run();
446         }
447         if (in)
448                 tcsetattr(0, TCSANOW, &in->t);
449         if (node) 
450                 close(node->cnum);
451         exit(i);
452 }
453
454 /*
455  * things to do with ongoing processing of inputs
456  */
457
458 void process_stdin()
459 {
460         cmsg_t *mp = cmsg_next(in->inq);
461         if (mp) {
462                 dbg(DMSG, "MSG size: %d", mp->size);
463         
464                 if (mp->size > 0 && mp->inp > mp->data) {
465                         send_msg(node, 'I', mp->data, mp->size);
466                 }
467                 cmsg_callback(mp, 0);
468         }
469 }
470
471 void process_node()
472 {
473         cmsg_t *mp = cmsg_next(node->inq);
474         if (mp) {
475                 dbg(DMSG, "MSG size: %d", mp->size);
476         
477                 if (mp->size > 0 && mp->inp > mp->data) {
478                         char *p = strchr(mp->data, '|');
479                         if (p)
480                                 p++;
481                         switch (mp->data[0]) {
482                         case 'Z':
483                                 send_Z = 0;
484                                 ending++;
485                                 return;
486                         case 'E':
487                                 if (isdigit(*p))
488                                         in->echo = *p - '0';
489                                 break;
490                         case 'D':
491                                 if (p) {
492                                         int l = mp->inp - (unsigned char *) p;
493                                         send_text(in, p, l);
494                         }
495                                 break;
496                         default:
497                                 break;
498                         }
499                 }
500                 cmsg_callback(mp, 0);
501         }
502 }
503
504 /*
505  * the program itself....
506  */
507
508 main(int argc, char *argv[])
509 {
510         initargs(argc, argv);
511         sel_init(10, 0, 10000);
512
513         signal(SIGHUP, SIG_IGN);
514
515         signal(SIGINT, terminate);
516         signal(SIGQUIT, terminate);
517         signal(SIGTERM, terminate);
518         signal(SIGPWR, terminate);
519
520         /* connect up stdin, stdout and message system */
521         in = fcb_new(0, TEXT);
522         in->sp = sel_open(0, in, "STDIN", fcb_handler, TEXT, SEL_INPUT);
523         if (tcgetattr(0, &in->t) < 0) 
524                 die("tcgetattr (%d)", errno);
525         {
526                 struct termios t = in->t;
527                 t.c_lflag &= ~(ECHO|ECHONL|ICANON);
528                 if (tcsetattr(0, TCSANOW, &t) < 0) 
529                         die("tcsetattr (%d)", errno);
530                 in->echo = echo;
531         }
532         connect_to_node();
533
534         /* tell the cluster who I am */
535         send_msg(node, 'A', connsort, strlen(connsort));
536         
537         /* main processing loop */
538         while (!ending) {
539                 sel_run();
540                 if (!ending) {
541                         process_stdin();
542                         process_node();
543                 }
544         }
545         terminate(0);
546 }
547
548
549
550
551
552