3 Copyright (C) 2004-2007 Chris Porter.
10 #include <sys/types.h>
11 #include <sys/socket.h>
14 #include <sys/ioctl.h>
18 #include <netinet/in.h>
19 #include <arpa/inet.h>
21 #include "../lib/sstring.h"
22 #include "../lib/irc_string.h"
23 #include "../core/config.h"
24 #include "../core/events.h"
25 #include "../lib/version.h"
26 #include "../core/schedule.h"
28 #include "nterfacer.h"
31 MODULE_VERSION("1.1p" PROTOCOL_VERSION
);
33 struct service_node
*tree
= NULL
;
34 struct esocket_events nterfacer_events
;
35 struct esocket
*nterfacer_sock
;
36 struct rline
*rlines
= NULL
;
37 unsigned short nterfacer_token
= BLANK_TOKEN
;
38 struct nterface_auto_log
*nrl
;
40 struct service_node
*ping
= NULL
;
42 struct permitted
*permits
;
45 int ping_handler(struct rline
*ri
, int argc
, char **argv
);
46 static void nterfacer_sendcallback(struct rline
*ri
, int error
, char *buf
);
50 int debug_mode
= getcopyconfigitemintpositive("nterfacer", "debug", 0);
52 nrl
= nterface_open_log("nterfacer", "logs/nterfacer.log", debug_mode
);
54 loaded
= load_permits();
55 nterface_log(nrl
, NL_INFO
, "Loaded %d permit%s successfully.", loaded
, loaded
==1?"":"s");
60 nterfacer_events
.on_accept
= nterfacer_accept_event
;
61 nterfacer_events
.on_line
= nterfacer_line_event
;
62 nterfacer_events
.on_disconnect
= NULL
;
64 nterfacer_token
= esocket_token();
66 ping
= register_service("nterfacer");
70 register_handler(ping
, "ping", 0, ping_handler
);
73 accept_fd
= setup_listening_socket();
75 nterface_log(nrl
, NL_ERROR
, "Unable to setup listening socket!");
77 nterfacer_sock
= esocket_add(accept_fd
, ESOCKET_UNIX_DOMAIN
, &nterfacer_events
, nterfacer_token
);
80 /* the main unix domain socket must NOT have a disconnect event. */
81 nterfacer_events
.on_disconnect
= nterfacer_disconnect_event
;
84 void free_handler(struct handler
*hp
) {
85 struct rline
*li
, *pi
= NULL
;
88 if(li
->handler
== hp
) {
90 esocket_write_line(li
->socket
, "%d,OE%d,%s", li
->id
, BF_UNLOADED
, "Service was unloaded.");
91 } else if(li
->callback
) {
92 nterfacer_sendcallback(li
, BF_UNLOADED
, "Service was unloaded.");
108 freesstring(hp
->command
);
112 void free_handlers(struct service_node
*tp
) {
113 struct handler
*hp
, *lp
;
115 for(hp
=tp
->handlers
;hp
;) {
125 struct service_node
*tp
, *lp
;
129 deregister_service(ping
);
139 if((accept_fd
!= -1) && nterfacer_sock
) {
140 esocket_clean_by_token(nterfacer_token
);
141 nterfacer_sock
= NULL
;
145 if(permits
&& permit_count
) {
146 for(i
=0;i
<permit_count
;i
++) {
147 freesstring(permits
[i
].hostname
);
148 freesstring(permits
[i
].password
);
155 nrl
= nterface_close_log(nrl
);
156 nscheckfreeall(POOL_NTERFACER
);
159 int load_permits(void) {
160 int loaded_lines
= 0, i
, j
;
161 struct permitted
*new_permits
, *resized
, *item
;
162 struct hostent
*host
;
163 array
*hostnamesa
, *passwordsa
;
164 sstring
**hostnames
, **passwords
;
166 hostnamesa
= getconfigitems("nterfacer", "hostname");
167 passwordsa
= getconfigitems("nterfacer", "password");
168 if(!hostnamesa
|| !passwordsa
)
170 if(hostnamesa
->cursi
!= passwordsa
->cursi
) {
171 nterface_log(nrl
, NL_ERROR
, "Different number of hostnames/passwords in config file.");
175 hostnames
= (sstring
**)hostnamesa
->content
;
176 passwords
= (sstring
**)passwordsa
->content
;
178 new_permits
= ntmalloc(hostnamesa
->cursi
* sizeof(struct permitted
));
179 memset(new_permits
, 0, hostnamesa
->cursi
* sizeof(struct permitted
));
182 for(i
=0;i
<hostnamesa
->cursi
;i
++) {
183 item
->hostname
= getsstring(hostnames
[i
]->content
, hostnames
[i
]->length
);
185 host
= gethostbyname(item
->hostname
->content
);
187 nterface_log(nrl
, NL_WARNING
, "Couldn't resolve hostname: %s (item %d).", item
->hostname
->content
, i
+ 1);
188 freesstring(item
->hostname
);
192 item
->ihost
= (*(struct in_addr
*)host
->h_addr_list
[0]).s_addr
;
193 for(j
=0;j
<loaded_lines
;j
++) {
194 if(new_permits
[j
].ihost
== item
->ihost
) {
195 nterface_log(nrl
, NL_WARNING
, "Host with items %d and %d is identical, dropping item %d.", j
+ 1, i
+ 1, i
+ 1);
201 freesstring(item
->hostname
);
205 item
->password
= getsstring(passwords
[i
]->content
, passwords
[i
]->length
);
206 nterface_log(nrl
, NL_DEBUG
, "Loaded permit, hostname: %s.", item
->hostname
->content
);
217 resized
= ntrealloc(new_permits
, sizeof(struct permitted
) * loaded_lines
);
224 permit_count
= loaded_lines
;
229 int setup_listening_socket(void) {
230 struct sockaddr_in sin
;
232 unsigned int opt
= 1;
234 fd
= socket(AF_INET
, SOCK_STREAM
, 0);
236 /* also shamelessly ripped from proxyscan */
238 nterface_log(nrl
, NL_ERROR
, "Unable to open listening socket (%d).", errno
);
242 if(setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *) &opt
, sizeof(opt
)) != 0) {
243 nterface_log(nrl
, NL_ERROR
, "Unable to set SO_REUSEADDR on listen socket.");
247 /* Initialiase the addresses */
248 memset(&sin
, 0, sizeof(sin
));
249 sin
.sin_family
= AF_INET
;
250 sin
.sin_port
= htons(getcopyconfigitemintpositive("nterfacer", "port", NTERFACER_PORT
));
252 if(bind(fd
, (struct sockaddr
*) &sin
, sizeof(sin
))) {
253 nterface_log(nrl
, NL_ERROR
, "Unable to bind listen socket (%d).", errno
);
259 if(ioctl(fd
, FIONBIO
, &opt
)) {
260 nterface_log(nrl
, NL_ERROR
, "Unable to set listen socket non-blocking.");
267 struct service_node
*register_service(char *name
) {
268 struct service_node
*np
= ntmalloc(sizeof(service_node
));
271 np
->name
= getsstring(name
, strlen(name
));
285 struct handler
*register_handler(struct service_node
*service
, char *command
, int args
, handler_function fp
) {
286 struct handler
*hp
= ntmalloc(sizeof(handler
));
289 hp
->command
= getsstring(command
, strlen(command
));
299 hp
->next
= service
->handlers
;
300 hp
->service
= service
;
301 service
->handlers
= hp
;
306 void deregister_handler(struct handler
*hl
) {
307 struct service_node
*service
= (struct service_node
*)hl
->service
;
308 struct handler
*np
, *lp
= NULL
;
309 for(np
=service
->handlers
;np
;lp
=np
,np
=np
->next
) {
314 service
->handlers
= np
->next
;
322 void deregister_service(struct service_node
*service
) {
323 struct service_node
*sp
, *lp
= NULL
;
325 for(sp
=tree
;sp
;lp
=sp
,sp
=sp
->next
) {
336 if(!sp
) /* already freed */
339 free_handlers(service
);
341 freesstring(service
->name
);
346 void nterfacer_accept_event(struct esocket
*socket
) {
347 struct sockaddr_in sin
;
348 unsigned int addrsize
= sizeof(sin
);
349 int newfd
= accept(socket
->fd
, (struct sockaddr
*)&sin
, &addrsize
), i
;
350 struct sconnect
*temp
;
351 struct permitted
*item
= NULL
;
352 struct esocket
*newsocket
;
353 unsigned int opt
= 1;
356 nterface_log(nrl
, NL_WARNING
, "Unable to accept nterfacer fd!");
360 if(ioctl(newfd
, FIONBIO
, &opt
)) {
361 nterface_log(nrl
, NL_ERROR
, "Unable to set accepted socket non-blocking.");
365 for(i
=0;i
<permit_count
;i
++) {
366 if(permits
[i
].ihost
== sin
.sin_addr
.s_addr
) {
373 nterface_log(nrl
, NL_INFO
, "Unauthorised connection from %s closed", inet_ntoa(sin
.sin_addr
));
378 temp
= (struct sconnect
*)ntmalloc(sizeof(struct sconnect
));
385 /* do checks on hostname first */
387 newsocket
= esocket_add(newfd
, ESOCKET_UNIX_DOMAIN_CONNECTED
, &nterfacer_events
, nterfacer_token
);
393 newsocket
->tag
= temp
;
395 nterface_log(nrl
, NL_INFO
, "New connection from %s.", item
->hostname
->content
);
397 temp
->status
= SS_IDLE
;
400 esocket_write_line(newsocket
, "nterfacer " PROTOCOL_VERSION
);
403 void derive_key(unsigned char *out
, char *password
, char *segment
, unsigned char *noncea
, unsigned char *nonceb
, unsigned char *extra
, int extralen
) {
406 SHA256_Update(&c
, (unsigned char *)password
, strlen(password
));
407 SHA256_Update(&c
, (unsigned char *)":", 1);
408 SHA256_Update(&c
, (unsigned char *)segment
, strlen(segment
));
409 SHA256_Update(&c
, (unsigned char *)":", 1);
410 SHA256_Update(&c
, noncea
, 16);
411 SHA256_Update(&c
, (unsigned char *)":", 1);
412 SHA256_Update(&c
, nonceb
, 16);
413 SHA256_Update(&c
, (unsigned char *)":", 1);
414 SHA256_Update(&c
, extra
, extralen
);
415 SHA256_Final(out
, &c
);
418 SHA256_Update(&c
, out
, 32);
419 SHA256_Final(out
, &c
);
422 int nterfacer_line_event(struct esocket
*sock
, char *newline
) {
423 struct sconnect
*socket
= sock
->tag
;
424 char *response
, *theirnonceh
= NULL
, *theirivh
= NULL
;
425 unsigned char theirnonce
[16], theiriv
[16];
428 switch(socket
->status
) {
430 if(strcasecmp(newline
, ANTI_FULL_VERSION
)) {
431 nterface_log(nrl
, NL_INFO
, "Protocol mismatch from %s: %s", socket
->permit
->hostname
->content
, newline
);
434 unsigned char challenge
[32];
435 char ivhex
[16 * 2 + 1], noncehex
[16 * 2 + 1];
437 if(!get_entropy(challenge
, 32) || !get_entropy(socket
->iv
, 16)) {
438 nterface_log(nrl
, NL_ERROR
, "Unable to open challenge/IV entropy bin!");
442 int_to_hex(challenge
, socket
->challenge
, 32);
443 int_to_hex(socket
->iv
, ivhex
, 16);
445 memcpy(socket
->response
, challenge_response(socket
->challenge
, socket
->permit
->password
->content
), sizeof(socket
->response
));
446 socket
->response
[sizeof(socket
->response
) - 1] = '\0'; /* just in case */
448 socket
->status
= SS_VERSIONED
;
449 if(!generate_nonce(socket
->ournonce
, 1)) {
450 nterface_log(nrl
, NL_ERROR
, "Unable to generate nonce!");
453 int_to_hex(socket
->ournonce
, noncehex
, 16);
455 if(esocket_write_line(sock
, "%s %s %s", socket
->challenge
, ivhex
, noncehex
))
461 for(response
=newline
;*response
;response
++) {
462 if((*response
== ' ') && (*(response
+ 1))) {
464 theirivh
= response
+ 1;
470 for(response
=theirivh
;*response
;response
++) {
471 if((*response
== ' ') && (*(response
+ 1))) {
473 theirnonceh
= response
+ 1;
479 if(!theirivh
|| (strlen(theirivh
) != 32) || !hex_to_int(theirivh
, theiriv
, sizeof(theiriv
)) ||
480 !theirnonceh
|| (strlen(theirnonceh
) != 32) || !hex_to_int(theirnonceh
, theirnonce
, sizeof(theirnonce
))) {
481 nterface_log(nrl
, NL_INFO
, "Protocol error drop: %s", socket
->permit
->hostname
->content
);
485 if(!memcmp(socket
->ournonce
, theirnonce
, sizeof(theirnonce
))) {
486 nterface_log(nrl
, NL_INFO
, "Bad nonce drop: %s", socket
->permit
->hostname
->content
);
490 if(!strncasecmp(newline
, socket
->response
, sizeof(socket
->response
))) {
491 unsigned char theirkey
[32], ourkey
[32];
493 derive_key(ourkey
, socket
->permit
->password
->content
, socket
->challenge
, socket
->ournonce
, theirnonce
, (unsigned char *)"SERVER", 6);
495 derive_key(theirkey
, socket
->permit
->password
->content
, socket
->response
, theirnonce
, socket
->ournonce
, (unsigned char *)"CLIENT", 6);
496 nterface_log(nrl
, NL_INFO
, "Authed: %s", socket
->permit
->hostname
->content
);
497 socket
->status
= SS_AUTHENTICATED
;
498 switch_buffer_mode(sock
, ourkey
, socket
->iv
, theirkey
, theiriv
);
500 if(esocket_write_line(sock
, "Oauth"))
503 nterface_log(nrl
, NL_INFO
, "Bad CR drop: %s", socket
->permit
->hostname
->content
);
508 case SS_AUTHENTICATED
:
509 nterface_log(nrl
, NL_INFO
|NL_LOG_ONLY
, "L(%s): %s", socket
->permit
->hostname
->content
, newline
);
510 reason
= nterfacer_new_rline(newline
, sock
, &number
);
512 if(reason
== RE_SOCKET_ERROR
)
514 if(reason
!= RE_BAD_LINE
) {
515 if(esocket_write_line(sock
, "%d,E%d,%s", number
, reason
, request_error(reason
)))
528 int nterfacer_new_rline(char *line
, struct esocket
*socket
, int *number
) {
529 char *sp
, *p
, *parsebuf
= NULL
, *pp
, commandbuf
[MAX_BUFSIZE
], *args
[MAX_ARGS
], *newp
;
531 struct service_node
*service
;
532 struct rline
*prequest
;
536 if(!line
|| !line
[0] || (line
[0] == ','))
539 for(sp
=line
;*sp
;sp
++)
543 if(!*sp
|| !*(sp
+ 1))
548 for(service
=tree
;service
;service
=service
->next
)
549 if(!strcmp(service
->name
->content
, line
))
560 *number
= positive_atoi(sp
+ 1);
562 if((*number
< 1) || (*number
> 0xffff))
566 nterface_log(nrl
, NL_DEBUG
, "Unable to find service: %s", line
);
567 return RE_SERVICER_NOT_FOUND
;
572 for(pp
=p
+1;*pp
;pp
++) {
573 if((*pp
== '\\') && *(pp
+ 1)) {
574 if(*(pp
+ 1) == ',') {
576 } else if(*(pp
+ 1) == '\\') {
580 } else if(*pp
== ',') {
587 if(*pp
== '\0') { /* if we're at the end already, we have no arguments */
590 argcount
= 1; /* we have a comma, so we have one already */
595 for(hl
=service
->handlers
;hl
;hl
=hl
->next
)
596 if(!strncmp(hl
->command
->content
, commandbuf
, sizeof(commandbuf
)))
600 return RE_COMMAND_NOT_FOUND
;
603 parsebuf
= (char *)ntmalloc(strlen(pp
) + 1);
604 MemCheckR(parsebuf
, RE_MEM_ERROR
);
607 for(newp
=args
[0]=parsebuf
,pp
++;*pp
;pp
++) {
608 if((*pp
== '\\') && *(pp
+ 1)) {
609 if(*(pp
+ 1) == ',') {
611 } else if(*(pp
+ 1) == '\\') {
615 } else if(*pp
== ',') {
617 args
[argcount
++] = newp
;
618 if(argcount
> MAX_ARGS
) {
620 return RE_TOO_MANY_ARGS
;
628 if(argcount
< hl
->args
) {
629 if(argcount
&& parsebuf
)
631 return RE_WRONG_ARG_COUNT
;
634 prequest
= (struct rline
*)ntmalloc(sizeof(struct rline
));
637 if(argcount
&& parsebuf
)
642 prequest
->service
= service
;
643 prequest
->handler
= hl
;
644 prequest
->buf
[0] = '\0';
645 prequest
->curpos
= prequest
->buf
;
646 prequest
->tag
= NULL
;
647 prequest
->id
= *number
;
648 prequest
->next
= rlines
;
649 prequest
->socket
= socket
;
650 prequest
->callback
= NULL
;
653 re
= (hl
->function
)(prequest
, argcount
, args
);
655 if(argcount
&& parsebuf
)
661 void nterfacer_disconnect_event(struct esocket
*sock
) {
662 struct sconnect
*socket
= sock
->tag
;
666 nterface_log(nrl
, NL_INFO
, "Disconnected from %s.", socket
->permit
->hostname
->content
);
669 for(li
=rlines
;li
;li
=li
->next
)
670 if(li
->socket
&& (li
->socket
->tag
== socket
))
676 int ri_append(struct rline
*li
, char *format
, ...) {
677 char buf
[MAX_BUFSIZE
], escapedbuf
[MAX_BUFSIZE
* 2 + 1], *p
, *tp
;
678 int sizeleft
= sizeof(li
->buf
) - (li
->curpos
- li
->buf
);
681 va_start(ap
, format
);
683 if(vsnprintf(buf
, sizeof(buf
), format
, ap
) >= sizeof(buf
)) {
690 for(tp
=escapedbuf
,p
=buf
;*p
||(*tp
='\0');*tp
++=*p
++)
691 if((*p
== ',') || (*p
== '\\'))
695 if(li
->curpos
== li
->buf
) {
696 li
->curpos
+=snprintf(li
->curpos
, sizeleft
, "%s", escapedbuf
);
698 li
->curpos
+=snprintf(li
->curpos
, sizeleft
, ",%s", escapedbuf
);
702 if(sizeof(li
->buf
) - (li
->curpos
- li
->buf
) > 0) {
709 int ri_error(struct rline
*li
, int error_code
, char *format
, ...) {
710 char buf
[MAX_BUFSIZE
], escapedbuf
[MAX_BUFSIZE
* 2 + 1], *p
, *tp
;
711 struct rline
*pp
, *lp
= NULL
;
715 if(li
->socket
|| li
->callback
) {
716 va_start(ap
, format
);
717 vsnprintf(buf
, sizeof(buf
), format
, ap
);
720 for(tp
=escapedbuf
,p
=buf
;*p
||(*tp
='\0');*tp
++=*p
++)
721 if((*p
== ',') || (*p
== '\\'))
724 if(esocket_write_line(li
->socket
, "%d,OE%d,%s", li
->id
, error_code
, escapedbuf
))
725 retval
= RE_SOCKET_ERROR
;
727 if(error_code
== 0) /* :P */
730 nterfacer_sendcallback(li
, error_code
, escapedbuf
);
734 for(pp
=rlines
;pp
;lp
=pp
,pp
=pp
->next
) {
749 int ri_final(struct rline
*li
) {
750 struct rline
*pp
, *lp
= NULL
;
754 if(esocket_write_line(li
->socket
, "%d,OO%s", li
->id
, li
->buf
))
755 retval
= RE_SOCKET_ERROR
;
756 } else if(li
->callback
) {
757 nterfacer_sendcallback(li
, 0, li
->buf
);
760 for(pp
=rlines
;pp
;lp
=pp
,pp
=pp
->next
) {
775 int ping_handler(struct rline
*ri
, int argc
, char **argv
) {
788 static const int XMAXARGS
= 50;
790 static void execrline(void *arg
) {
791 struct sched_rline
*sr
= arg
;
793 char *argv
[XMAXARGS
], *buf
;
798 for(i
=0;i
<sr
->argc
;i
++) {
800 buf
+=strlen(buf
) + 1;
803 re
= (sr
->hl
->function
)(&sr
->rl
, sr
->argc
, argv
);
806 Error("nterfacer", ERR_WARNING
, "sendline: error occured calling %p %d: %s", sr
->hl
->function
, re
, request_error(re
));
809 void *nterfacer_sendline(char *service
, char *command
, int argc
, char **argv
, rline_callback callback
, void *tag
) {
810 struct service_node
*servicep
;
811 struct rline
*prequest
;
812 struct sched_rline
*sr
;
817 for(servicep
=tree
;servicep
;servicep
=servicep
->next
)
818 if(!strcmp(servicep
->name
->content
, service
))
822 Error("nterfacer", ERR_STOP
, "Over maximum arguments.");
825 Error("nterfacer", ERR_WARNING
, "sendline: service not found: %s", service
);
829 for(hl
=servicep
->handlers
;hl
;hl
=hl
->next
)
830 if(!strcmp(hl
->command
->content
, command
))
834 Error("nterfacer", ERR_WARNING
, "sendline: command not found: %s", command
);
838 if(argc
< hl
->args
) {
839 Error("nterfacer", ERR_WARNING
, "sendline: wrong number of arguments: %s", command
);
843 /* we have to create a copy of the arguments for reentrancy reasons, grr */
846 totallen
+=strlen(argv
[i
]) + 1;
848 /* HACKY but allows existing code to still work */
849 sr
= (struct sched_rline
*)ntmalloc(sizeof(struct sched_rline
) + totallen
);
858 for(i
=0;i
<argc
;i
++) {
859 size_t len
= strlen(argv
[i
]) + 1;
860 memcpy(buf
, argv
[i
], len
);
865 prequest
->service
= servicep
;
866 prequest
->handler
= hl
;
867 prequest
->buf
[0] = '\0';
868 prequest
->curpos
= prequest
->buf
;
871 prequest
->socket
= NULL
;
872 prequest
->callback
= callback
;
874 prequest
->next
= rlines
;
877 scheduleoneshot(time(NULL
), execrline
, sr
);
882 void nterfacer_freeline(void *tag
) {
883 struct sched_rline
*prequest
= tag
;
885 prequest
->rl
.callback
= NULL
;
886 if(prequest
->schedule
)
887 deleteschedule(prequest
->schedule
, execrline
, NULL
);
890 #define MAX_LINES 8192
893 static void nterfacer_sendcallback(struct rline
*ri
, int error
, char *buf
) {
894 char *lines
[MAX_LINES
+1];
895 char newbuf
[MAX_BUFSIZE
+5];
896 char *s
, *d
, *laststart
;
899 for(s
=buf
,laststart
=d
=newbuf
;*s
;s
++) {
900 if((*s
== '\\') && *(s
+ 1)) {
901 if(*(s
+ 1) == ',') {
903 } else if(*(s
+ 1) == '\\') {
907 } else if(*s
== ',') {
909 if(linec
>= MAX_LINES
- 5) {
910 nterfacer_sendcallback(ri
, BF_OVER
, "Buffer overflow.");
914 lines
[linec
++] = laststart
;
921 lines
[linec
++] = laststart
;
923 ri
->callback(error
, linec
, lines
, ri
->tag
);