Updated Gaim plugin info.
[doldaconnect.git] / lib / uilib.c
... / ...
CommitLineData
1/*
2 * Dolda Connect - Modular multiuser Direct Connect-style client
3 * Copyright (C) 2004 Fredrik Tolf (fredrik@dolda2000.com)
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18*/
19
20/*
21 * Note: This code is still ugly, since I copied it almost verbatim
22 * from the daemon's parser. It would need serious cleanups, but at
23 * least it works for now.
24 */
25
26#ifdef HAVE_CONFIG_H
27#include <config.h>
28#endif
29#include <stdio.h>
30#include <unistd.h>
31#include <stdlib.h>
32#include <string.h>
33#include <iconv.h>
34#include <wchar.h>
35#include <wctype.h>
36#include <errno.h>
37#include <stdarg.h>
38#include <sys/socket.h>
39#include <netinet/in.h>
40#include <arpa/inet.h>
41#include <sys/un.h>
42#include <fcntl.h>
43#include <netdb.h>
44#include <sys/poll.h>
45#include <pwd.h>
46#ifdef HAVE_RESOLVER
47#include <arpa/nameser.h>
48#include <resolv.h>
49#endif
50
51#include <doldaconnect/uilib.h>
52#include <utils.h>
53
54#define DOLCON_SRV_NAME "_dolcon._tcp"
55
56#define RESP_END -1
57#define RESP_DSC 0
58#define RESP_STR 1
59#define RESP_INT 2
60#define RESP_FLOAT 3
61
62struct respclass
63{
64 struct respclass *next;
65 int code;
66 int nwords;
67 int *wordt;
68};
69
70struct command
71{
72 struct command *next;
73 wchar_t *name;
74 struct respclass *classes;
75};
76
77struct qcmd
78{
79 struct qcmd *next;
80 struct command *cmd;
81 int tag;
82 char *buf;
83 size_t buflen;
84 int (*callback)(struct dc_response *resp);
85 void *data;
86};
87
88void dc_uimisc_disconnected(void);
89
90/* The first command must be the nameless connect command and second
91 * the notification command. */
92static struct command *commands = NULL;
93static struct qcmd *queue = NULL, *queueend = NULL;
94static struct dc_response *respqueue = NULL, *respqueueend = NULL;
95static int state = -1;
96static int fd = -1;
97static iconv_t ichandle;
98static int resetreader = 1;
99static struct addrinfo *hostlist = NULL, *curhost = NULL;
100struct {
101 char *hostname;
102 int family;
103 int sentcreds;
104} servinfo;
105
106static struct dc_response *makeresp(void)
107{
108 struct dc_response *new;
109
110 new = smalloc(sizeof(*new));
111 new->next = NULL;
112 new->prev = NULL;
113 new->code = 0;
114 new->cmdname = NULL;
115 new->rlines = NULL;
116 new->linessize = 0;
117 new->numlines = 0;
118 new->curline = 0;
119 new->data = NULL;
120 return(new);
121}
122
123static void freeqcmd(struct qcmd *qcmd)
124{
125 if(qcmd->buf != NULL)
126 free(qcmd->buf);
127 free(qcmd);
128}
129
130static void unlinkqueue(void)
131{
132 struct qcmd *qcmd;
133
134 if((qcmd = queue) == NULL)
135 return;
136 queue = qcmd->next;
137 if(queue == NULL)
138 queueend = NULL;
139 freeqcmd(qcmd);
140}
141
142static struct qcmd *makeqcmd(wchar_t *name)
143{
144 struct qcmd *new;
145 struct command *cmd;
146 static int tag = 0;
147
148 if(name == NULL)
149 {
150 cmd = commands;
151 } else {
152 for(cmd = commands; cmd != NULL; cmd = cmd->next)
153 {
154 if((cmd->name != NULL) && !wcscmp(cmd->name, name))
155 break;
156 }
157 if(cmd == NULL)
158 return(NULL);
159 }
160 new = smalloc(sizeof(*new));
161 new->tag = tag++;
162 new->cmd = cmd;
163 new->buf = NULL;
164 new->buflen = 0;
165 new->callback = NULL;
166 new->next = NULL;
167 new->data = NULL;
168 if(queueend == NULL)
169 {
170 queue = queueend = new;
171 } else {
172 queueend->next = new;
173 queueend = new;
174 }
175 return(new);
176}
177
178static wchar_t *quoteword(wchar_t *word)
179{
180 wchar_t *wp, *buf, *bp;
181 int dq, numbs, numc;
182
183 dq = 0;
184 numbs = 0;
185 numc = 0;
186 if(*word == L'\0')
187 {
188 dq = 1;
189 } else {
190 for(wp = word; *wp != L'\0'; wp++)
191 {
192 if(!dq && iswspace(*wp))
193 dq = 1;
194 if((*wp == L'\\') || (*wp == L'\"'))
195 numbs++;
196 numc++;
197 }
198 }
199 if(!dq && !numbs)
200 return(NULL);
201 bp = buf = smalloc(sizeof(wchar_t) * (numc + numbs + (dq?2:0) + 1));
202 if(dq)
203 *(bp++) = L'\"';
204 for(wp = word; *wp != L'\0'; wp++)
205 {
206 if((*wp == L'\\') || (*wp == L'\"'))
207 *(bp++) = L'\\';
208 *(bp++) = *wp;
209 }
210 if(dq)
211 *(bp++) = L'\"';
212 *(bp++) = L'\0';
213 return(buf);
214}
215
216static struct command *makecmd(wchar_t *name)
217{
218 struct command *new;
219
220 new = smalloc(sizeof(*new));
221 new->name = name;
222 new->classes = NULL;
223 new->next = commands;
224 commands = new;
225 return(new);
226}
227
228static struct respclass *addresp(struct command *cmd, int code, ...)
229{
230 struct respclass *new;
231 int i;
232 int resps[128];
233 va_list args;
234
235 va_start(args, code);
236 i = 0;
237 while((resps[i++] = va_arg(args, int)) != RESP_END);
238 i--;
239 va_end(args);
240 new = smalloc(sizeof(*new));
241 new->code = code;
242 new->nwords = i;
243 if(i > 0)
244 {
245 new->wordt = smalloc(sizeof(int) * i);
246 memcpy(new->wordt, resps, sizeof(int) * i);
247 } else {
248 new->wordt = NULL;
249 }
250 new->next = cmd->classes;
251 cmd->classes = new;
252 return(new);
253}
254
255#include "initcmds.h"
256
257int dc_init(void)
258{
259 if((ichandle = iconv_open("wchar_t", "utf-8")) == (iconv_t)-1)
260 return(-1);
261 initcmds();
262 return(0);
263}
264
265void dc_cleanup(void)
266{
267 iconv_close(ichandle);
268}
269
270void dc_disconnect(void)
271{
272 struct dc_response *resp;
273
274 state = -1;
275 if(fd >= 0)
276 close(fd);
277 fd = -1;
278 while(queue != NULL)
279 unlinkqueue();
280 while((resp = dc_getresp()) != NULL)
281 dc_freeresp(resp);
282 dc_uimisc_disconnected();
283 if(servinfo.hostname != NULL)
284 free(servinfo.hostname);
285 memset(&servinfo, 0, sizeof(servinfo));
286}
287
288void dc_freeresp(struct dc_response *resp)
289{
290 int i, o;
291
292 for(i = 0; i < resp->numlines; i++)
293 {
294 for(o = 0; o < resp->rlines[i].argc; o++)
295 free(resp->rlines[i].argv[o]);
296 free(resp->rlines[i].argv);
297 }
298 free(resp->rlines);
299 free(resp);
300}
301
302struct dc_response *dc_getresp(void)
303{
304 struct dc_response *ret;
305
306 if((ret = respqueue) == NULL)
307 return(NULL);
308 respqueue = ret->next;
309 if(respqueue == NULL)
310 respqueueend = NULL;
311 else
312 respqueue->prev = NULL;
313 return(ret);
314}
315
316struct dc_response *dc_gettaggedresp(int tag)
317{
318 struct dc_response *resp;
319
320 for(resp = respqueue; resp != NULL; resp = resp->next)
321 {
322 if(resp->tag == tag)
323 {
324 if(resp->prev != NULL)
325 resp->prev->next = resp->next;
326 if(resp->next != NULL)
327 resp->next->prev = resp->prev;
328 if(resp == respqueue)
329 respqueue = resp->next;
330 if(resp == respqueueend)
331 respqueueend = resp->prev;
332 return(resp);
333 }
334 }
335 return(NULL);
336}
337
338struct dc_response *dc_gettaggedrespsync(int tag)
339{
340 struct pollfd pfd;
341 struct dc_response *resp;
342
343 while((resp = dc_gettaggedresp(tag)) == NULL)
344 {
345 pfd.fd = fd;
346 pfd.events = POLLIN;
347 if(dc_wantwrite())
348 pfd.events |= POLLOUT;
349 if(poll(&pfd, 1, -1) < 0)
350 return(NULL);
351 if((pfd.revents & POLLIN) && dc_handleread())
352 return(NULL);
353 if((pfd.revents & POLLOUT) && dc_handlewrite())
354 return(NULL);
355 }
356 return(resp);
357}
358
359int dc_wantwrite(void)
360{
361 switch(state)
362 {
363 case 1:
364 if((queue != NULL) && (queue->buflen > 0))
365 return(1);
366 break;
367 }
368 return(0);
369}
370
371int dc_getstate(void)
372{
373 return(state);
374}
375
376int dc_queuecmd(int (*callback)(struct dc_response *), void *data, ...)
377{
378 struct qcmd *qcmd;
379 int num, freepart;
380 va_list al;
381 char *final;
382 wchar_t **toks;
383 wchar_t *buf;
384 wchar_t *part, *tpart;
385 size_t bufsize, bufdata;
386
387 buf = NULL;
388 bufsize = bufdata = 0;
389 num = 0;
390 va_start(al, data);
391 while((part = va_arg(al, wchar_t *)) != NULL)
392 {
393 if(!wcscmp(part, L"%%a"))
394 {
395 for(toks = va_arg(al, wchar_t **); *toks != NULL; toks++)
396 {
397 part = *toks;
398 freepart = 0;
399 if((tpart = quoteword(part)) != NULL)
400 {
401 freepart = 1;
402 part = tpart;
403 }
404 addtobuf(buf, L' ');
405 bufcat(buf, part, wcslen(part));
406 num++;
407 if(freepart)
408 free(part);
409 }
410 } else {
411 if(*part == L'%')
412 {
413 /* This demands that all arguments that are passed to the
414 * function are of equal length, that of an int. I know
415 * that GCC does that on IA32 platforms, but I do not know
416 * which other platforms and compilers that it applies
417 * to. If this breaks your platform, please mail me about
418 * it.
419 */
420 part = vswprintf2(tpart = (part + 1), al);
421 for(; *tpart != L'\0'; tpart++)
422 {
423 if(*tpart == L'%')
424 {
425 if(tpart[1] == L'%')
426 tpart++;
427 else
428 va_arg(al, int);
429 }
430 }
431 freepart = 1;
432 } else {
433 freepart = 0;
434 }
435 if((tpart = quoteword(part)) != NULL)
436 {
437 if(freepart)
438 free(part);
439 part = tpart;
440 freepart = 1;
441 }
442 if(num > 0)
443 addtobuf(buf, L' ');
444 if(num == 0)
445 {
446 if((qcmd = makeqcmd(part)) == NULL)
447 {
448 if(freepart)
449 free(part);
450 if(buf != NULL)
451 free(buf);
452 return(-1);
453 } else {
454 qcmd->callback = callback;
455 qcmd->data = data;
456 }
457 }
458 bufcat(buf, part, wcslen(part));
459 num++;
460 if(freepart)
461 free(part);
462 }
463 }
464 bufcat(buf, L"\r\n\0", 3);
465 if((final = icwcstombs(buf, "utf-8")) == NULL)
466 {
467 free(buf);
468 return(-1);
469 }
470 va_end(al);
471 free(buf);
472 qcmd->buf = final;
473 qcmd->buflen = strlen(final);
474 return(qcmd->tag);
475}
476
477int dc_handleread(void)
478{
479 int ret, done;
480 char *p1, *p2;
481 size_t len;
482 socklen_t optlen;
483 int errnobak;
484 /* Ewww... this really is soo ugly. I need to clean this up some day. */
485 static int pstate = 0;
486 static char inbuf[128];
487 static size_t inbufdata = 0;
488 static wchar_t *cbuf = NULL;
489 static size_t cbufsize = 0, cbufdata = 0;
490 static wchar_t *pptr = NULL;
491 static wchar_t **argv = NULL;
492 static int argc = 0;
493 static size_t args = 0;
494 static wchar_t *cw = NULL;
495 static size_t cwsize = 0, cwdata = 0;
496 static struct dc_response *curresp = NULL;
497 static int cont = 0;
498 static int unlink = 0;
499
500 switch(state)
501 {
502 case -1:
503 return(-1);
504 case 0:
505 optlen = sizeof(ret);
506 getsockopt(fd, SOL_SOCKET, SO_ERROR, &ret, &optlen);
507 if(ret)
508 {
509 int newfd;
510
511 for(curhost = curhost->ai_next; curhost != NULL; curhost = curhost->ai_next)
512 {
513 if((newfd = socket(curhost->ai_family, curhost->ai_socktype, curhost->ai_protocol)) < 0)
514 {
515 errnobak = errno;
516 dc_disconnect();
517 errno = errnobak;
518 return(-1);
519 }
520 dup2(newfd, fd);
521 close(newfd);
522 fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
523 if(connect(fd, (struct sockaddr *)curhost->ai_addr, curhost->ai_addrlen))
524 {
525 if(errno == EINPROGRESS)
526 return(0);
527 } else {
528 break;
529 }
530 }
531 if(curhost == NULL)
532 {
533 dc_disconnect();
534 errno = ret;
535 return(-1);
536 }
537 }
538 if(curhost->ai_canonname != NULL)
539 servinfo.hostname = sstrdup(curhost->ai_canonname);
540 servinfo.family = curhost->ai_family;
541 state = 1;
542 resetreader = 1;
543 break;
544 case 1:
545 if(resetreader)
546 {
547 inbufdata = 0;
548 cbufdata = 0;
549 pptr = NULL;
550 pstate = 0;
551 resetreader = 0;
552 cont = 0;
553 if(curresp != NULL)
554 dc_freeresp(curresp);
555 curresp = NULL;
556 }
557 if(inbufdata == 128)
558 inbufdata = 0;
559 ret = read(fd, inbuf + inbufdata, 128 - inbufdata);
560 if(ret < 0)
561 {
562 if((errno == EAGAIN) || (errno == EINTR))
563 return(0);
564 errnobak = errno;
565 dc_disconnect();
566 errno = errnobak;
567 return(-1);
568 } else if(ret == 0) {
569 dc_disconnect();
570 errno = 0;
571 return(-1);
572 }
573 inbufdata += ret;
574 done = 0;
575 while(!done)
576 {
577 if(cbufsize == cbufdata)
578 {
579 if(pptr != NULL)
580 len = pptr - cbuf;
581 if((cbuf = realloc(cbuf, sizeof(wchar_t) * (cbufsize += 256))) == NULL)
582 {
583 dc_disconnect();
584 errno = ENOMEM;
585 return(-1);
586 }
587 if(pptr != NULL)
588 pptr = cbuf + len;
589 }
590 p1 = inbuf;
591 p2 = (char *)(cbuf + cbufdata);
592 len = sizeof(wchar_t) * (cbufsize - cbufdata);
593 ret = iconv(ichandle, &p1, &inbufdata, &p2, &len);
594 memmove(inbuf, p1, inbufdata);
595 cbufdata = cbufsize - (len / sizeof(wchar_t));
596 if(ret < 0)
597 {
598 switch(errno)
599 {
600 case EILSEQ:
601 /* XXX Is this really OK? */
602 inbufdata = 0;
603 done = 1;
604 break;
605 case EINVAL:
606 done = 1;
607 break;
608 case E2BIG:
609 break;
610 default:
611 errnobak = errno;
612 dc_disconnect();
613 errno = errnobak;
614 return(-1);
615 }
616 } else {
617 done = 1;
618 }
619 }
620 if(pptr == NULL)
621 pptr = cbuf;
622 done = 0;
623 while(!done && (pptr - cbuf < cbufdata))
624 {
625 switch(pstate)
626 {
627 case 0:
628 if(iswspace(*pptr))
629 {
630 if(*pptr == L'\r')
631 {
632 if(pptr == cbuf + cbufdata - 1)
633 {
634 done = 1;
635 break;
636 }
637 if(*(++pptr) == L'\n')
638 {
639 if(curresp == NULL)
640 {
641 curresp = makeresp();
642 if((argc > 0) && ((curresp->code = wcstol(argv[0], NULL, 10)) >= 600))
643 {
644 curresp->cmdname = L".notify";
645 curresp->internal = commands->next;
646 curresp->tag = -1;
647 unlink = 0;
648 } else {
649 if((curresp->cmdname = queue->cmd->name) == NULL)
650 curresp->cmdname = L".connect";
651 curresp->data = queue->data;
652 curresp->tag = queue->tag;
653 curresp->internal = (void *)(queue->cmd);
654 unlink = 1;
655 }
656 }
657 sizebuf(&curresp->rlines, &curresp->linessize, curresp->numlines + 1, sizeof(*(curresp->rlines)), 1);
658 curresp->rlines[curresp->numlines].argc = argc;
659 curresp->rlines[curresp->numlines].argv = argv;
660 argv = NULL;
661 argc = args = 0;
662 curresp->numlines++;
663 if(!cont)
664 {
665 if((curresp->code >= 600) || (queue == NULL) || (queue->callback == NULL))
666 ret = 0;
667 else
668 ret = queue->callback(curresp);
669 if(ret == 0)
670 {
671 if(respqueue == NULL)
672 {
673 respqueue = respqueueend = curresp;
674 } else {
675 curresp->next = NULL;
676 curresp->prev = respqueueend;
677 respqueueend->next = curresp;
678 respqueueend = curresp;
679 }
680 } else if(ret == 1) {
681 dc_freeresp(curresp);
682 }
683 curresp = NULL;
684 if(unlink)
685 unlinkqueue();
686 }
687 wmemmove(cbuf, pptr, cbufdata -= (pptr - cbuf));
688 pptr = cbuf;
689 } else {
690 pptr++;
691 }
692 } else {
693 pptr++;
694 }
695 } else {
696 pstate = 1;
697 cwdata = 0;
698 }
699 break;
700 case 1:
701 if(iswspace(*pptr) || ((argc == 0) && (*pptr == L'-')))
702 {
703 if(argc == 0)
704 {
705 if(*pptr == L'-')
706 {
707 cont = 1;
708 pptr++;
709 } else {
710 cont = 0;
711 }
712 }
713 addtobuf(cw, L'\0');
714 sizebuf(&argv, &args, argc + 1, sizeof(*argv), 1);
715 argv[argc++] = cw;
716 cw = NULL;
717 cwsize = cwdata = 0;
718 pstate = 0;
719 } else if(*pptr == L'\"') {
720 pstate = 2;
721 pptr++;
722 } else if(*pptr == L'\\') {
723 if(pptr == cbuf + cbufdata - 1)
724 {
725 done = 1;
726 break;
727 }
728 addtobuf(cw, *(++pptr));
729 pptr++;
730 } else {
731 addtobuf(cw, *(pptr++));
732 }
733 break;
734 case 2:
735 if(*pptr == L'\"')
736 {
737 pstate = 1;
738 } else if(*pptr == L'\\') {
739 addtobuf(cw, *(++pptr));
740 } else {
741 addtobuf(cw, *pptr);
742 }
743 pptr++;
744 break;
745 }
746 }
747 break;
748 }
749 return(0);
750}
751
752static void mkcreds(struct msghdr *msg)
753{
754 struct ucred *ucred;
755 static char buf[CMSG_SPACE(sizeof(*ucred))];
756 struct cmsghdr *cmsg;
757
758 msg->msg_control = buf;
759 msg->msg_controllen = sizeof(buf);
760 cmsg = CMSG_FIRSTHDR(msg);
761 cmsg->cmsg_level = SOL_SOCKET;
762 cmsg->cmsg_type = SCM_CREDENTIALS;
763 cmsg->cmsg_len = CMSG_LEN(sizeof(*ucred));
764 ucred = (struct ucred *)CMSG_DATA(cmsg);
765 ucred->pid = getpid();
766 ucred->uid = getuid();
767 ucred->gid = getgid();
768 msg->msg_controllen = cmsg->cmsg_len;
769}
770
771int dc_handlewrite(void)
772{
773 int ret;
774 int errnobak;
775 struct msghdr msg;
776 struct iovec bufvec;
777
778 switch(state)
779 {
780 case 1:
781 if(queue->buflen > 0)
782 {
783 memset(&msg, 0, sizeof(msg));
784 msg.msg_iov = &bufvec;
785 msg.msg_iovlen = 1;
786 bufvec.iov_base = queue->buf;
787 bufvec.iov_len = queue->buflen;
788 if((servinfo.family == PF_UNIX) && !servinfo.sentcreds)
789 {
790 mkcreds(&msg);
791 servinfo.sentcreds = 1;
792 }
793 ret = sendmsg(fd, &msg, MSG_NOSIGNAL | MSG_DONTWAIT);
794 if(ret < 0)
795 {
796 if((errno == EAGAIN) || (errno == EINTR))
797 return(0);
798 errnobak = errno;
799 dc_disconnect();
800 errno = errnobak;
801 return(-1);
802 }
803 if(ret > 0)
804 memmove(queue->buf, queue->buf + ret, queue->buflen -= ret);
805 }
806 break;
807 }
808 return(0);
809}
810
811#ifdef HAVE_RESOLVER
812/*
813 * It kind of sucks that libresolv doesn't have any DNS parsing
814 * routines. We'll have to do it manually.
815 */
816static char *readname(unsigned char *msg, unsigned char *eom, unsigned char **p)
817{
818 char *name, *tname;
819 unsigned char *tp;
820 size_t namesize, namedata, len;
821
822 name = NULL;
823 namesize = namedata = 0;
824 while(1)
825 {
826 len = *((*p)++);
827 if(len == 0)
828 {
829 addtobuf(name, 0);
830 return(name);
831 } else if(len == 0xc0) {
832 tp = msg + *((*p)++);
833 if((tname = readname(msg, eom, &tp)) == NULL)
834 {
835 if(name != NULL)
836 free(name);
837 return(NULL);
838 }
839 bufcat(name, tname, strlen(tname));
840 addtobuf(name, 0);
841 free(tname);
842 return(name);
843 } else if(*p + len >= eom) {
844 if(name != NULL)
845 free(name);
846 return(NULL);
847 }
848 bufcat(name, *p, len);
849 *p += len;
850 addtobuf(name, '.');
851 }
852}
853
854static int skipname(unsigned char *msg, unsigned char *eom, unsigned char **p)
855{
856 size_t len;
857
858 while(1)
859 {
860 len = *((*p)++);
861 if(len == 0)
862 {
863 return(0);
864 } else if(len == 0xc0) {
865 (*p)++;
866 return(0);
867 } else if(*p + len >= eom) {
868 return(-1);
869 }
870 *p += len;
871 }
872}
873
874static int getsrvrr(char *name, char **host, int *port)
875{
876 int i;
877 char *name2, *rrname;
878 unsigned char *eom, *p;
879 unsigned char buf[1024];
880 int flags, num, class, type;
881 size_t len;
882 int ret;
883
884 if(!(_res.options & RES_INIT))
885 {
886 if(res_init() < 0)
887 return(-1);
888 }
889 /* res_querydomain doesn't work for some reason */
890 if(name[strlen(name) - 1] == '.')
891 name2 = sprintf2("%s.%s", DOLCON_SRV_NAME, name);
892 else
893 name2 = sprintf2("%s.%s.", DOLCON_SRV_NAME, name);
894 ret = res_query(name2, C_IN, T_SRV, buf, sizeof(buf));
895 if(ret < 0)
896 {
897 free(name2);
898 return(-1);
899 }
900 eom = buf + ret;
901 /*
902 * Assume transaction ID is correct.
903 *
904 * Flags check: FA0F masks in request/response flag, opcode,
905 * truncated flag and status code, and ignores authoritativeness,
906 * recursion flags and DNSSEC and reserved bits.
907 */
908 flags = (buf[2] << 8) + buf[3];
909 if((flags & 0xfa0f) != 0x8000)
910 {
911 free(name2);
912 return(-1);
913 }
914 /* Skip the query entries */
915 num = (buf[4] << 8) + buf[5];
916 p = buf + 12;
917 for(i = 0; i < num; i++)
918 {
919 if(skipname(buf, eom, &p))
920 {
921 free(name2);
922 return(-1);
923 }
924 p += 4; /* Type and class */
925 }
926 /* Parse answers */
927 num = (buf[6] << 8) + buf[7];
928 for(i = 0; i < num; i++)
929 {
930 if((rrname = readname(buf, eom, &p)) == NULL)
931 {
932 free(name2);
933 return(-1);
934 }
935 type = *(p++) << 8;
936 type += *(p++);
937 class = *(p++) << 8;
938 class += *(p++);
939 p += 4; /* TTL */
940 len = *(p++) << 8;
941 len += *(p++);
942 if((class == C_IN) && (type == T_SRV) && !strcmp(rrname, name2))
943 {
944 free(rrname);
945 free(name2);
946 /* Noone will want to have alternative DC servers, so
947 * don't care about priority and weigth */
948 p += 4;
949 if(port == NULL)
950 {
951 p += 2;
952 } else {
953 *port = *(p++) << 8;
954 *port += *(p++);
955 }
956 if(host != NULL)
957 {
958 if((rrname = readname(buf, eom, &p)) == NULL)
959 return(-1);
960 *host = rrname;
961 }
962 return(0);
963 }
964 p += len;
965 free(rrname);
966 }
967 free(name2);
968 return(-1);
969}
970#else
971static int getsrvrr(char *name, char **host, int *port)
972{
973 errno = EOPNOTSUPP;
974 return(-1);
975}
976#endif
977
978static struct addrinfo *gaicat(struct addrinfo *l1, struct addrinfo *l2)
979{
980 struct addrinfo *p;
981
982 if(l1 == NULL)
983 return(l2);
984 for(p = l1; p->ai_next != NULL; p = p->ai_next);
985 p->ai_next = l2;
986 return(l1);
987}
988
989/* This isn't actually correct, in any sense of the word. It only
990 * works on systems whose getaddrinfo implementation saves the
991 * sockaddr in the same malloc block as the struct addrinfo. Those
992 * systems include at least FreeBSD and glibc-based systems, though,
993 * so it should not be any immediate threat, and it allows me to not
994 * implement a getaddrinfo wrapper. It can always be changed, should
995 * the need arise. */
996static struct addrinfo *unixgai(int type, char *path)
997{
998 void *buf;
999 struct addrinfo *ai;
1000 struct sockaddr_un *un;
1001
1002 buf = smalloc(sizeof(*ai) + sizeof(*un));
1003 memset(buf, 0, sizeof(*ai) + sizeof(*un));
1004 ai = (struct addrinfo *)buf;
1005 un = (struct sockaddr_un *)(buf + sizeof(*ai));
1006 ai->ai_flags = 0;
1007 ai->ai_family = AF_UNIX;
1008 ai->ai_socktype = type;
1009 ai->ai_protocol = 0;
1010 ai->ai_addrlen = sizeof(*un);
1011 ai->ai_addr = (struct sockaddr *)un;
1012 ai->ai_canonname = NULL;
1013 ai->ai_next = NULL;
1014 un->sun_family = PF_UNIX;
1015 strncpy(un->sun_path, path, sizeof(un->sun_path) - 1);
1016 return(ai);
1017}
1018
1019static struct addrinfo *resolvtcp(char *name, int port)
1020{
1021 struct addrinfo hint, *ret;
1022 char tmp[32];
1023
1024 memset(&hint, 0, sizeof(hint));
1025 hint.ai_socktype = SOCK_STREAM;
1026 hint.ai_flags = AI_NUMERICSERV | AI_CANONNAME;
1027 snprintf(tmp, sizeof(tmp), "%i", port);
1028 if(!getaddrinfo(name, tmp, &hint, &ret))
1029 return(ret);
1030 return(NULL);
1031}
1032
1033static struct addrinfo *resolvsrv(char *name)
1034{
1035 struct addrinfo *ret;
1036 char *realname;
1037 int port;
1038
1039 if(getsrvrr(name, &realname, &port))
1040 return(NULL);
1041 ret = resolvtcp(realname, port);
1042 free(realname);
1043 return(ret);
1044}
1045
1046static struct addrinfo *resolvhost(char *host)
1047{
1048 char *p, *hp;
1049 struct addrinfo *ret;
1050 int port;
1051
1052 if(strchr(host, '/'))
1053 return(unixgai(SOCK_STREAM, host));
1054 if((strchr(host, ':') == NULL) && ((ret = resolvsrv(host)) != NULL))
1055 return(ret);
1056 ret = NULL;
1057 if((*host == '[') && ((p = strchr(host, ']')) != NULL))
1058 {
1059 hp = memcpy(smalloc(p - host), host + 1, (p - host) - 1);
1060 hp[(p - host) - 1] = 0;
1061 if(strchr(hp, ':') != NULL) {
1062 port = 0;
1063 if(*(++p) == ':')
1064 port = atoi(p + 1);
1065 if(port == 0)
1066 port = 1500;
1067 ret = resolvtcp(hp, port);
1068 }
1069 free(hp);
1070 }
1071 if(ret != NULL)
1072 return(ret);
1073 hp = sstrdup(host);
1074 port = 0;
1075 if((p = strrchr(hp, ':')) != NULL) {
1076 *(p++) = 0;
1077 port = atoi(p);
1078 }
1079 if(port == 0)
1080 port = 1500;
1081 ret = resolvtcp(hp, port);
1082 free(hp);
1083 if(ret != NULL)
1084 return(ret);
1085 return(NULL);
1086}
1087
1088static struct addrinfo *defaulthost(void)
1089{
1090 struct addrinfo *ret;
1091 struct passwd *pwd;
1092 char *tmp;
1093 char dn[1024];
1094
1095 if(((tmp = getenv("DCSERVER")) != NULL) && *tmp)
1096 return(resolvhost(tmp));
1097 ret = NULL;
1098 if((getuid() != 0) && ((pwd = getpwuid(getuid())) != NULL))
1099 {
1100 tmp = sprintf2("/tmp/doldacond-%s", pwd->pw_name);
1101 ret = gaicat(ret, unixgai(SOCK_STREAM, tmp));
1102 free(tmp);
1103 }
1104 ret = gaicat(ret, unixgai(SOCK_STREAM, "/var/run/doldacond.sock"));
1105 ret = gaicat(ret, resolvtcp("localhost", 1500));
1106 if(!getdomainname(dn, sizeof(dn)) && *dn && strcmp(dn, "(none)"))
1107 ret = gaicat(ret, resolvsrv(dn));
1108 return(ret);
1109}
1110
1111int dc_connect(char *host)
1112{
1113 struct qcmd *qcmd;
1114 int errnobak;
1115
1116 if(fd >= 0)
1117 dc_disconnect();
1118 state = -1;
1119 if(hostlist != NULL)
1120 freeaddrinfo(hostlist);
1121 if(!host || !*host)
1122 hostlist = defaulthost();
1123 else
1124 hostlist = resolvhost(host);
1125 if(hostlist == NULL)
1126 return(-1);
1127 for(curhost = hostlist; curhost != NULL; curhost = curhost->ai_next)
1128 {
1129 if((fd = socket(curhost->ai_family, curhost->ai_socktype, curhost->ai_protocol)) < 0)
1130 {
1131 errnobak = errno;
1132 errno = errnobak;
1133 return(-1);
1134 }
1135 fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
1136 if(connect(fd, (struct sockaddr *)curhost->ai_addr, curhost->ai_addrlen))
1137 {
1138 if(errno == EINPROGRESS)
1139 {
1140 state = 0;
1141 break;
1142 }
1143 close(fd);
1144 fd = -1;
1145 } else {
1146 if(curhost->ai_canonname != NULL)
1147 servinfo.hostname = sstrdup(curhost->ai_canonname);
1148 servinfo.family = curhost->ai_family;
1149 state = 1;
1150 break;
1151 }
1152 }
1153 qcmd = makeqcmd(NULL);
1154 resetreader = 1;
1155 return(fd);
1156}
1157
1158struct dc_intresp *dc_interpret(struct dc_response *resp)
1159{
1160 int i;
1161 struct dc_intresp *iresp;
1162 struct command *cmd;
1163 struct respclass *cls;
1164 int code;
1165 size_t args;
1166
1167 if((resp->numlines == 0) || (resp->rlines[0].argc == 0) || (resp->curline >= resp->numlines))
1168 return(NULL);
1169 code = wcstol(resp->rlines[0].argv[0], NULL, 10);
1170 cmd = (struct command *)(resp->internal);
1171 for(cls = cmd->classes; cls != NULL; cls = cls->next)
1172 {
1173 if(cls->code == code)
1174 break;
1175 }
1176 if(cls == NULL)
1177 return(NULL);
1178 if(cls->nwords >= resp->rlines[resp->curline].argc)
1179 return(NULL);
1180 iresp = smalloc(sizeof(*iresp));
1181 iresp->code = code;
1182 iresp->argv = NULL;
1183 iresp->argc = 0;
1184 args = 0;
1185 for(i = 0; i < cls->nwords; i++)
1186 {
1187 switch(cls->wordt[i])
1188 {
1189 case RESP_DSC:
1190 break;
1191 case RESP_STR:
1192 sizebuf(&(iresp->argv), &args, iresp->argc + 1, sizeof(*(iresp->argv)), 1);
1193 iresp->argv[iresp->argc].val.str = swcsdup(resp->rlines[resp->curline].argv[i + 1]);
1194 iresp->argv[iresp->argc].type = cls->wordt[i];
1195 iresp->argc++;
1196 break;
1197 case RESP_INT:
1198 sizebuf(&(iresp->argv), &args, iresp->argc + 1, sizeof(*(iresp->argv)), 1);
1199 iresp->argv[iresp->argc].val.num = wcstol(resp->rlines[resp->curline].argv[i + 1], NULL, 0);
1200 iresp->argv[iresp->argc].type = cls->wordt[i];
1201 iresp->argc++;
1202 break;
1203 case RESP_FLOAT:
1204 sizebuf(&(iresp->argv), &args, iresp->argc + 1, sizeof(*(iresp->argv)), 1);
1205 iresp->argv[iresp->argc].val.flnum = wcstod(resp->rlines[resp->curline].argv[i + 1], NULL);
1206 iresp->argv[iresp->argc].type = cls->wordt[i];
1207 iresp->argc++;
1208 break;
1209 }
1210 }
1211 resp->curline++;
1212 return(iresp);
1213}
1214
1215void dc_freeires(struct dc_intresp *ires)
1216{
1217 int i;
1218
1219 for(i = 0; i < ires->argc; i++)
1220 {
1221 if(ires->argv[i].type == RESP_STR)
1222 free(ires->argv[i].val.str);
1223 }
1224 free(ires->argv);
1225 free(ires);
1226}
1227
1228const char *dc_gethostname(void)
1229{
1230 return(servinfo.hostname);
1231}