aiccu/0000775000175200017530000000000010142107763007153 500000000000000aiccu/Makefile0000664000175200017530000001426310142112157010532 00000000000000# /********************************************************** # SixXS - Automatic IPv6 Connectivity Configuration Utility # *********************************************************** # Copyright 2003-2004 SixXS - http://www.sixxs.net # *********************************************************** # Packaging Makefile # *********************************************************** # $Author: jeroen $ # $Id: Makefile,v 1.9 2004/11/03 08:18:55 jeroen Exp $ # $Date: 2004/11/03 08:18:55 $ # **********************************************************/ # # Note for BSD people: use GNU Make (gmake) PROJECT=aiccu PROJECT_DESC="Automatic IPv6 Connectivity Configuration Utility" PROJECT_VERSION=2004.09.17-BETA2b # Misc bins RM=@rm -f MAKE:=@${MAKE} CP=@echo [Copy]; cp RPMBUILD=@echo [RPMBUILD]; rpmbuild RPMBUILD_SILENCE=>/dev/null 2>/dev/null # Excludes for limited source release EXCLUDES=--exclude "${PROJECT}/windows-*" --exclude common/aiccu_win32.c --exclude CVS # Change this if you want to install into another dirtree # Required for eg the Debian Package builder DESTDIR= export DESTDIR # Get the source dir, needed for eg debsrc SOURCEDIR := $(shell pwd) SOURCEDIRNAME := $(shell basename `pwd`) # This may be updated by RPM's for instance CFLAGS=${RPM_OPT_FLAGS} # Destination Paths (relative to DESTDIR) dirsbin=/usr/sbin/ dirbin=/usr/bin/ diretc=/etc/ dirdoc=/usr/share/doc/${PROJECT}/ # Make sure the lower makefile also knows these export PROJECT export PROJECT_DESC export PROJECT_VERSION export PROJECT_COPYRIGHT export DESTDIR export SOURCEDIR export RM export MV export CC export CP export MAKE export dirsbin export dirbin export diretc export dirdoc export RPM_OPT_FLAGS #################### ## Makefile Targets #################### all: Makefile unix-console/ @echo "Building : $(PROJECT) - $(PROJECT_DESC)" @echo "Copyright : SixXS" @echo "Version : $(PROJECT_VERSION)" $(MAKE) -C unix-console all @echo "Building done" install: aiccu @echo "Installing into ${DESTDIR}..." @echo "Binaries..." @mkdir -p ${DESTDIR}${dirsbin} $(MAKE) -C unix-console install @mkdir -p ${DESTDIR}${dirdoc} @echo "Configuration..." @mkdir -p ${DESTDIR}${diretc} $(shell [ -f ${DESTDIR}${diretc}${PROJECT}.conf ] || cp -R doc/${PROJECT}.conf ${DESTDIR}${diretc}${PROJECT}.conf) ifeq ($(shell echo "A${RPM_BUILD_ROOT}"),A) @echo "Documentation..." @cp doc/README ${DESTDIR}${dirdoc} @cp doc/LICENSE ${DESTDIR}${dirdoc} @cp doc/HOWTO ${DESTDIR}${dirdoc} @echo "Installing Debian-style init.d" @mkdir -p ${DESTDIR}${diretc}init.d @cp doc/${PROJECT}.init ${DESTDIR}${diretc}init.d/${PROJECT} else @echo "Installing Redhat-style init.d" @mkdir -p ${DESTDIR}${diretc}init.d @cp doc/${PROJECT}.init.rpm ${DESTDIR}${diretc}init.d/${PROJECT} endif @echo "Installation into ${DESTDIR}/ completed" help: @echo "$(PROJECT) - $(PROJECT_DESC)" @echo @echo "Makefile targets:" @echo "all : Build everything" @echo "help : This little text" @echo "install : Build & Install into ${DESTDIR}/" @echo "clean : Clean the dirs to be pristine in bondage" @echo @echo "Distribution targets:" @echo "dist : Make all distribution targets" @echo "tar : Make source tarball (tar.gz)" @echo "bz2 : Make source tarball (tar.bz2)" @echo "deb : Make Debian binary package (.deb)" @echo "debsrc : Make Debian source packages" @echo "rpm : Make RPM package (.rpm)" @echo "rpmsrc : Make RPM source packages" @echo @echo "SixXS targets:" @echo "tarfull : Full tar including Windows directories" @echo "bz2full : Full bz2 including Windows directories" aiccu: doc unix-console/ $(MAKE) -C unix-console all doc: doc/aiccu.1 doc/aiccu.1: doc/aiccu.sgml docbook-to-man doc/aiccu.sgml >doc/aiccu.1 clean: debclean rpmclean $(MAKE) -C unix-console clean -${RM} -r windows-gui/Debug -${RM} -r windows-gui/Release -${RM} windows-gui/AICCU.APS -${RM} windows-gui/AICCU.ncb -${RM} -r windows-console/Debug -${RM} -r windows-console/Release -${RM} windows-console/AICCU.APS -${RM} windows-console/AICCU.ncb # Generate Distribution files dist: tar bz2 deb debsrc rpm rpmsrc # tar.gz tar: clean -${RM} ../${PROJECT}_${PROJECT_VERSION}.tar.gz tar -zclo -C .. ${EXCLUDES} -f ../${PROJECT}_${PROJECT_VERSION}.tar.gz ${PROJECT} # tar.gz (full) tarfull: clean -${RM} ../${PROJECT}_${PROJECT_VERSION}.tar.gz tar -zclo -C .. -f ../${PROJECT}_${PROJECT_VERSION}.tar.gz ${PROJECT} # tar.bz2 bz2: clean -${RM} ../${PROJECT}_${PROJECT_VERSION}.tar.bz2 tar -jclo -C .. ${EXCLUDES} -f ../${PROJECT}_${PROJECT_VERSION}.tar.bz2 ${PROJECT} # tar.bz2 (full) bz2full: clean -${RM} ../${PROJECT}_${PROJECT_VERSION}.tar.bz2 tar -jclo -C .. -f ../${PROJECT}_${PROJECT_VERSION}.tar.bz2 ${PROJECT} # .deb deb: clean # Copy the changelog ${CP} doc/changelog debian/changelog ${CP} doc/${PROJECT}.init debian/${PROJECT}.init debian/rules binary ${MAKE} clean # Source .deb debsrc: clean # Copy the changelog ${CP} doc/changelog debian/changelog cd ..; dpkg-source -b ${SOURCEDIR}; cd ${SOURCEDIR} ${MAKE} clean # Cleanup after debian debclean: if [ -f build-stamp ]; then debian/rules clean; fi # RPM rpm: rpmclean tar -${RM} /usr/src/redhat/RPMS/i386/${PROJECT}-*.rpm ${RPMBUILD} -tb --define '${PROJECT}_version ${PROJECT_VERSION}' ../${PROJECT}_${PROJECT_VERSION}.tar.gz ${RPMBUILD_SILENCE} @if [ -d /usr/src/redhat/RPMS/i386/ ]; then mv /usr/src/redhat/RPMS/i386/${PROJECT}-*.rpm ../; fi @if [ -d /usr/src/rpm/RPMS/i386/ ]; then mv /usr/src/rpm/RPMS/i386/${PROJECT}-*.rpm ../; fi @echo "Resulting RPM's:" @ls -l ../${PROJECT}-*.rpm ${MAKE} clean @echo "RPMBuild done" rpmsrc: rpmclean tar -${RM} /usr/src/redhat/RPMS/i386/${PROJECT}-*src.rpm ${RPMBUILD} -ts --define '${PROJECT}_version ${PROJECT_VERSION}' ../${PROJECT}_${PROJECT_VERSION}.tar.gz ${RPMBUILD_SILENCE} @if [ -d /usr/src/redhat/RPMS/i386/ ]; then mv /usr/src/redhat/RPMS/i386/${PROJECT}-*.src.rpm ../; fi @if [ -d /usr/src/rpm/RPMS/i386/ ]; then mv /usr/src/rpm/RPMS/i386/${PROJECT}-*.src.rpm ../; fi @echo "Resulting RPM's:" @ls -l ../${PROJECT}-*.rpm ${MAKE} clean} @echo "RPMBuild-src done" rpmclean: clean -${RM} ../${PROJECT}_${PROJECT_VERSION}.tar.gz # Mark targets as phony .PHONY : all install help clean dist tar bz2 deb debsrc debclean rpm rpmsrc aiccu/common/0000775000175200017530000000000010160264732010443 500000000000000aiccu/common/common.c0000775000175200017530000003172210140406534012023 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/common.c - Common Functions *********************************************************** $Author: jeroen $ $Id: common.c,v 1.3 2004/10/29 09:29:00 jeroen Exp $ $Date: 2004/10/29 09:29:00 $ **********************************************************/ /* Dirty dependency for Windows:GUI version */ #ifdef _WIN32 #ifndef AICCU_CONSOLE #include "../windows-gui/stdafx.h" #include "../windows-gui/AICCUApp.h" extern CAICCUApp theApp; #endif #endif #include "aiccu.h" #include "common.h" /* getline debugging? */ /* #define E(x) x */ #define E(x) {} void dologA(int level, const char *fmt, va_list ap) { /* Don't show noise */ if (g_aiccu && !g_aiccu->verbose && level == LOG_DEBUG) return; #ifndef _WIN32 if (g_aiccu && g_aiccu->daemonize > 0) vsyslog(LOG_LOCAL7|level, fmt, ap); else vprintf(fmt, ap); #else char buf[1024]; vsnprintf(buf,sizeof(buf),fmt,ap); #ifndef AICCU_CONSOLE OutputDebugString(buf); /* * Always store the last message * which can be displayed as errors etc. */ /* strip the \n */ if (strlen(buf) > 0) buf[strlen(buf)-1] = '\0'; theApp.m_sMessage = buf; #else OutputDebugString("dolog() - "); OutputDebugString(buf); printf("%s", buf); #endif /* AICCU_CONSOLE */ #endif /* !_WIN32 */ } void dolog(int level, const char *fmt, ...) { va_list ap; va_start(ap, fmt); dologA(level, fmt, ap); va_end(ap); } #ifndef _WIN32 int sigrunning(int sig) { int pid; FILE *f = fopen(AICCU_PID, "r"); if (!f) return 0; fscanf(f, "%d", &pid); fclose(f); /* If we can HUP it, it still runs */ return (kill(pid, sig) == 0 ? 1 : 0); } void savepid() { FILE *f = fopen(AICCU_PID, "w"); if (!f) return; fprintf(f, "%d", getpid()); fclose(f); dolog(LOG_INFO, "Running as PID %d", getpid()); } void cleanpid(int i) { dolog(LOG_INFO, "Exiting on signal %d...", i); unlink(AICCU_PID); exit(0); } #endif /* _WIN32 */ /* * Check if an address is RFC1918 based * This allows us to warn the user that they are behind a NAT */ bool is_rfc1918(char *ipv4) { unsigned int addr = inet_addr(ipv4); bool ret = false; ret = ( /* 10.0.0.0/8 */ ((addr & htonl(0xff000000)) == htonl(0x0a000000)) || /* 172.16.0.0/12 */ ((addr & htonl(0xfff00000)) == htonl(0xac100000)) || /* 192.168.0.0/16 */ ((addr & htonl(0xffff0000)) == htonl(0xc0a80000))) ? true : false; dolog(LOG_DEBUG, "is_rfc1918(%s) = %s\n", ipv4, ret ? "yes" : "false"); return ret; } void sock_printf(SOCKET sock, const char *fmt, ...) { char buf[2048]; unsigned int len = 0; va_list ap; va_start(ap, fmt); /* When not a socket send it to the logs */ if (sock == -1) dologA(LOG_INFO, fmt, ap); else { /* Format the string */ len = vsnprintf(buf, sizeof(buf), fmt, ap); /* Send the line(s) over the network */ send(sock, buf, len, 0); /* Show this as debug output */ if (g_aiccu->verbose) { /* Strip the last \n */ len = (int)strlen(buf); if (len > 0) buf[len-1] = '\0'; /* dump the information */ dolog(LOG_DEBUG, "sock_printf() : \"%s\"\n", buf); } } va_end(ap); } extern char tic_buf[2048]; /* * Read a line from a socket and store it in ubuf * Note: uses internal caching, this should be the only function * used to read from the sock! The internal cache is rbuf. */ int sock_getline(SOCKET sock, char *rbuf, unsigned int rbuflen, unsigned int *filled, char *ubuf, unsigned int ubuflen) { unsigned int i; /* A closed socket? -> clear the buffer */ if (sock == -1) { memset(rbuf, 0, rbuflen); *filled = 0; return -1; } /* Clear the caller supplied buffer, just in case */ memset(ubuf, 0, ubuflen); for (;;) { E(dolog(LOG_DEBUG, "gl() - Filled %d\n", *filled);) /* Did we still have something in the buffer? */ if (*filled > 0) { E(dolog(LOG_DEBUG, "gl() - Seeking newline\n");) /* Walk to the end or until we reach a \n */ for (i=0; (i < (*filled-1)) && (rbuf[i] != '\n'); i++); E(dolog(LOG_DEBUG, "gl() - Seeking newline - end\n");) /* Did we find a newline? */ if (rbuf[i] == '\n') { E(dolog(LOG_DEBUG, "gl() - Found newline at %i\n", i+1);) /* Newline with a Linefeed in front of it ? -> remove it */ if (rbuf[i] == '\n' && rbuf[i-1] == '\r') { E(dolog(LOG_DEBUG, "gl() - Removing LF\n");) i--; } E(else dolog(LOG_DEBUG, "gl() - No LF\n");) /* Copy this over to the caller */ memcpy(ubuf, rbuf, i); E(dolog(LOG_DEBUG, "gl() - Copied %d bytes from %x to %x\n", i, rbuf, ubuf);) /* Count the \r if it is there */ if (rbuf[i] == '\r') i++; /* Count the \n */ i++; /* filled = what is left in the buffer */ *filled -= i; E(dolog(LOG_DEBUG, "gl() - %d bytes left in the buffer\n", *filled);) /* Now move the rest of the buffer to the front */ if (*filled > 0) memmove(rbuf, &rbuf[i], *filled); else *filled = 0; /* Show this as debug output */ if (g_aiccu->verbose) dolog(LOG_DEBUG, "sock_getline() : \"%s\"\n", ubuf); /* We got ourselves a line in 'buf' thus return to the caller */ return i; } } E(dolog(LOG_DEBUG, "gl() - Trying to receive (max=%d)...\n", rbuflen-*filled-10);) /* Fill the rest of the buffer */ i = recv(sock, &rbuf[*filled], rbuflen-*filled-10, 0); E(dolog(LOG_DEBUG, "gl() - Received %d\n", i);) /* Fail on errors */ if (i <= 0) return -1; /* We got more filled space! */ *filled+=i; /* Buffer overflow? */ if ( *filled >= (rbuflen-10) || *filled >= (ubuflen-10) ) { dolog(LOG_ERR, "Buffer almost flowed over without receiving a newline\n"); return -1; } /* And try again in this loop ;) */ } /* Never reached */ return -1; } /* Connect this client to a server */ SOCKET connect_client(const char *hostname, const char *service, int family, int socktype) { SOCKET sock = -1; struct addrinfo hints, *res, *ressave; memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = family; hints.ai_socktype = socktype; if (getaddrinfo(hostname, service, &hints, &res) != 0) { dolog(LOG_ERR, "Couldn't resolve host %s, service %s\n", hostname, service); return -1; } ressave = res; while (res) { sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol); if (sock == -1) continue; if (connect(sock, res->ai_addr, (unsigned int)res->ai_addrlen) == 0) break; closesocket(sock); sock = -1; res = res->ai_next; } freeaddrinfo(ressave); return sock; } SOCKET listen_server(const char *description, const char *hostname, const char *service, int family, int socktype) { struct addrinfo hints, *res, *ressave; int n; SOCKET sock; socklen_t on = 1; /* D(dolog(LOG_DEBUG, "[%s] Trying to get socket for [%s]:%s over %s (%d) using %s (%d)\n", description, hostname, service, family == AF_INET ? "IPv4" : (family == AF_INET6 ? "IPv6" : "??"), family, socktype == IPPROTO_UDP ? "UDP" : (socktype == IPPROTO_TCP ? "TCP" : "??"), socktype);) */ memset(&hints, 0, sizeof(struct addrinfo)); /* AI_PASSIVE flag: the resulting address is used to bind to a socket for accepting incoming connections. So, when the hostname==NULL, getaddrinfo function will return one entry per allowed protocol family containing the unspecified address for that family. */ hints.ai_flags = AI_PASSIVE; hints.ai_family = family; hints.ai_socktype = socktype; n = getaddrinfo(hostname, service, &hints, &res); if (n < 0) { dolog(LOG_ERR, "[%s] listen_server setup: getaddrinfo error: %s\n", description, gai_strerror(n)); return -1; } ressave=res; /* Try to open socket with each address getaddrinfo returned, until we get one valid listening socket. */ sock = -1; while (res) { sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol); if (!(sock < 0)) { setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on)); if (bind(sock, res->ai_addr, (unsigned int)res->ai_addrlen) == 0) break; closesocket(sock); sock = -1; } res = res->ai_next; } if (sock < 0) { freeaddrinfo(ressave); dolog(LOG_ERR, "[%s] listen setup: socket error: could not open socket\n", description); return -1; } listen(sock, LISTEN_QUEUE); dolog(LOG_INFO, "[%s] Listening on [%s]:%s\n", description, hostname, service); freeaddrinfo(ressave); return sock; } /* Count the number of fields in */ unsigned int countfields(char *s) { int n = 1, i; if (s == NULL) return 0; for (i=0; s[i] != '\0'; i++) if (s[i] == ' ') n++; return n; } /* * Copy field of string into with a maximum of buflen * First field is 1 */ bool copyfield(char *s, unsigned int n, char *buf, unsigned int buflen) { unsigned int begin = 0, i=0; /* Clear the buffer */ memset(buf, 0, buflen); while (s[i] != '\0') { n--; begin = i; /* Find next delimiter */ for (; s[i] != '\0' && s[i] != ' '; i++); if (n == 0) { i-=begin; strncpy(buf, s+begin, i > buflen ? buflen : i); /* dolog(LOG_DEBUG, "copyfield() : '%s', begin = %d, len = %d\n", buf, begin, i); */ return true; } i++; } dolog(LOG_WARNING, "copyfield() - Field %u didn't exist in '%s'\n", n, s); return false; } bool parseline(char *line, const char *split, struct pl_rule *rules, void *data) { unsigned int r, len; char *end = NULL, *val = NULL, *p = NULL; void *store; /* Chop off \n and \r and white space */ p = &line[strlen(line)-1]; while ( p >= line && ( *p == '\n' || *p == '\r' || *p == '\t' || *p == ' ')) *p-- = '\0'; /* Ignore comments and emtpy lines */ if ( strlen(line) == 0 || line[0] == '#' || line[0] == ';' || (line[0] == '/' && line[1] == '/')) { return true; } /* Get the end of the first argument */ p = line; end = &line[strlen(line)-1]; /* Skip until whitespace */ while ( p < end && strncmp(p, split, strlen(split)) != 0) p++; /* Terminate this argument */ *p = '\0'; p++; /* Skip whitespace */ while ( p < end && *p == ' ' && *p == '\t') p++; /* Start of the value */ val = p+(strlen(split)-1); /* If starting with quotes, skip until next quote */ if (*p == '"' || *p == '\'') { p++; /* Find next quote */ while (p <= end && *p != *val && *p != '\0') p++; /* Terminate */ *p = '\0'; /* Skip the first quote */ val++; } /* Otherwise it is already terminated above */ /* Walk through all the rules */ for (r = 0; rules[r].type != PLRT_END; r++) { len = (int)strlen(rules[r].title); if (strncmp(line, rules[r].title, len) != 0) continue; store = (void *)((char *)data + rules[r].offset); switch (rules[r].type) { case PLRT_STRING: if (*((char **)store)) free(*((char **)store)); *((char **)store) = strdup(val); break; case PLRT_INTEGER: *((unsigned int *)store) = atoi(val); break; case PLRT_BOOL: if ( strcmp(val, "yes") == 0 || strcmp(val, "true") == 0) { *((bool *)store) = true; } else if (strcmp(val, "no") == 0 || strcmp(val, "false") == 0) { *((bool *)store) = false; } else { dolog(LOG_WARNING, "Unknown boolean value \"%s\" for option \"%s\"\n", val, rules[r].title); } break; case PLRT_IPV4: inet_pton(AF_INET, val, store); break; case PLRT_IPV6: inet_pton(AF_INET6, val, store); break; case PLRT_END: return false; } return true; } return false; } /* * MD5 a string * sSignature's size MUST be 32 bytes! */ void MD5String(char *sString, char *sSignature, unsigned int siglen) { struct MD5Context md5c; unsigned char signature[16]; unsigned int i; if (siglen < 32) return; /* Initialize MD5 structure */ MD5Init(&md5c); /* Calculate MD5 of the string */ MD5Update(&md5c, (unsigned char *)sString, (unsigned int)strlen(sString)); MD5Final(signature, &md5c); memset(sSignature, 0, siglen); for (i=0; i < sizeof(signature); i++) { snprintf(&sSignature[i*2], 3, "%02x", signature[i]); } } #ifdef _WIN32 const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt) { if (af == AF_INET) { struct sockaddr_in in; memset(&in, 0, sizeof(in)); in.sin_family = AF_INET; memcpy(&in.sin_addr, src, sizeof(struct in_addr)); getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST); return dst; } else if (af == AF_INET6) { struct sockaddr_in6 in; memset(&in, 0, sizeof(in)); in.sin6_family = AF_INET6; memcpy(&in.sin6_addr, src, sizeof(struct in_addr6)); getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST); return dst; } return NULL; } int inet_pton(int af, const char *src, void *dst) { struct addrinfo hints, *res, *ressave; memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = af; if (getaddrinfo(src, NULL, &hints, &res) != 0) { dolog(LOG_ERR, "Couldn't resolve host %s\n", src); return -1; } ressave = res; while (res) { memcpy(dst, res->ai_addr, res->ai_addrlen); res = res->ai_next; } freeaddrinfo(ressave); return 0; } #endif aiccu/common/common.h0000775000175200017530000001214410120277342012026 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/common.h - Common Definitions *********************************************************** $Author: jeroen $ $Id: common.h,v 1.4 2004/09/10 10:16:02 jeroen Exp $ $Date: 2004/09/10 10:16:02 $ **********************************************************/ #ifndef AICCU_COMMON_H #define AICCU_COMMON_H "H5K7:W3NDY5UU5N1K1N1C0l3" #ifdef _DEBUG #define D(x) x #else #define D(x) {} #endif #ifndef __OpenBSD__ #define _XOPEN_SOURCE #endif #define __STRICT_ANSI__ #include #include #include #include #include #include #include #include #include #include #include /* For MD5 routines */ #define __USE_BSD 1 #include #ifndef _WIN32 /* Unix Specifics */ #ifndef linux #include #endif #include #include #include #include #include #include #include #include #include #include #include #ifdef linux #include #include #endif #include #include #include #include #include #include #include #include /* * Windows abstracts sockets to a different * type, as this is actually pretty nice * we'll do it too */ #ifndef SOCKET typedef int SOCKET; #endif /* closesocket() -> close() on unices */ #define closesocket close #else /* Windows Specifics */ #include /* Winsock */ #include #include /* * Some weird M$ person thought it was * funny to underscore common functions !? */ #define snprintf _snprintf #define vsnprintf _vsnprintf #define strcasecmp _stricmp #define strncasecmp _strnicmp /* * Capitalize this one * Sleep() is in milliseconds */ #define sleep(x) Sleep(x*1000) /* No syslog on Windows */ #define LOG_DEBUG 1 #define LOG_ERR 2 #define LOG_WARNING 3 #define LOG_INFO 4 #ifdef __alpha typedef unsigned int u_int32_t; #else typedef unsigned long u_int32_t; #endif typedef unsigned char u_int8_t; typedef unsigned __int16 u_int16_t; /* Not available in the Winsock2 includes */ #define IPPROTO_NONE 59 /* IPv6 no next header */ #define BIG_ENDIAN 4321 #define LITTLE_ENDIAN 1234 #define __BIG_ENDIAN BIG_ENDIAN #define __LITTLE_ENDIAN LITTLE_ENDIAN /* Fix byte order */ #ifdef __alpha #define __BYTE_ORDER __BIG_ENDIAN #define BYTE_ORDER BIG_ENDIAN #else #define __BYTE_ORDER __LITTLE_ENDIAN #define BYTE_ORDER LITTLE_ENDIAN #endif const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt); int inet_pton(int af, const char *src, void *dst); #endif /* WIN32 */ #ifndef LITTLE_ENDIAN #define LITTLE_ENDIAN __LITTLE_ENDIAN #endif #ifndef BIG_ENDIAN #define BIG_ENDIAN __BIG_ENDIAN #endif #ifndef PDP_ENDIAN #define PDP_ENDIAN __PDP_ENDIAN #endif #ifndef BYTE_ORDER #define BYTE_ORDER __BYTE_ORDER #endif /* Boolean support */ #ifndef bool #define bool int #endif #ifndef false #define false 0 #endif #ifndef true #define true (!false) #endif #ifndef offsetof #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) #endif /* Include MD5 and SHA1 support */ #include "hash_md5.h" #include "hash_sha1.h" /* parseline() rules */ enum pl_ruletype { PLRT_STRING, /* Offset points to a String (strdup()) */ PLRT_INTEGER, /* Offset points to a Integer (unsigned int) */ PLRT_BOOL, /* Offset points to a Boolean. */ PLRT_IPV4, /* Offset points to a IPv4 address (inet_pton(..., AF_INET)) */ PLRT_IPV6, /* Offset points to a IPv6 address (inet_pton(..., AF_INET6)) */ PLRT_END /* End of rules */ }; struct pl_rule { const char *title; enum pl_ruletype type; unsigned int offset; }; /* Common Functions */ void dologA(int level, const char *fmt, va_list ap); void dolog(int level, const char *fmt, ...); #ifndef _WIN32 int sigrunning(int sig); void savepid(void); void cleanpid(int i); #endif /* Networking functions */ void sock_printf(SOCKET sock, const char *fmt, ...); int sock_getline(SOCKET sock, char *rbuf, unsigned int rbuflen, unsigned int *filled, char *ubuf, unsigned int ubuflen); SOCKET connect_client(const char *hostname, const char *service, int family, int socktype); SOCKET listen_server(const char *description, const char *hostname, const char *service, int family, int socktype); /* Parsing functions */ unsigned int countfields(char *s); bool copyfield(char *s, unsigned int n, char *buf, unsigned int buflen); bool parseline(char *line, const char *split, struct pl_rule *rules, void *data); /* Convienience */ void MD5String(char *sString, char *sSignature, unsigned int siglen); bool is_rfc1918(char *ipv4); #endif /* AICCU_COMMON_H */ aiccu/common/aiccu_openbsd.c0000775000175200017530000000302610140406767013335 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu_openbsd.c - OpenBSD *********************************************************** $Author: jeroen $ $Id: aiccu_openbsd.c,v 1.5 2004/10/29 09:31:35 jeroen Exp $ $Date: 2004/10/29 09:31:35 $ **********************************************************/ #include "aiccu.h" void aiccu_os_install() { } void aiccu_os_setup(struct TIC_Tunnel *hTunnel) { if (strcmp(hTunnel->sType, "ayiya") != 0) { aiccu_exec( "/sbin/ifconfig %s tunnel %s %s", g_aiccu->ipv6_interface, strcmp(hTunnel->sIPv4_Local, "heartbeat") == 0 ? "0.0.0.0" : hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } aiccu_exec( "ifconfig %s up", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s inet6 %s %s prefixlen 128 alias", g_aiccu->ipv6_interface, hTunnel->sIPv6_Local, hTunnel->sIPv6_POP); aiccu_exec( "route add -inet6 %s %s", "default", hTunnel->sIPv6_POP); } void aiccu_os_reconfig(struct TIC_Tunnel *hTunnel) { aiccu_exec( "/sbin/ifconfig %s tunnel %s %s", g_aiccu->ipv6_interface, hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } void aiccu_os_delete(struct TIC_Tunnel *hTunnel) { hTunnel = hTunnel; aiccu_exec( "ifconfig %s down", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s deletetunnel", g_aiccu->ipv6_interface); } aiccu/common/aiccu.h0000775000175200017530000000505010115321377011622 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu.h - Abstracted Functions and Configuration All compile-time configurable items are in this file *********************************************************** $Author: jeroen $ $Id: aiccu.h,v 1.2 2004/09/01 10:22:55 jeroen Exp $ $Date: 2004/09/01 10:22:55 $ **********************************************************/ #ifndef AICCU_H #define AICCU_H "H5K7:W3NDY5UU5N1K1N1C0l3" #include "common.h" #include "tic.h" #include "heartbeat.h" #include "ayiya.h" /* AICCU Version */ #define AICCU_VER "2004.08.29-BETA2" #define AICCU_VERSION_NUM 2004,08,29,0 /* _NUM = required for Windows Resources */ /* Append -gui or -console? */ #ifndef AICCU_CONSOLE #define AICCU_VERSION AICCU_VER "-gui" #else #define AICCU_VERSION AICCU_VER "-console" #endif /* Need for TIC */ #define TIC_CLIENT_NAME "AICCU" #define TIC_CLIENT_VERSION AICCU_VERSION /* * AICCU configuration Cache * allows reconnects even when we don't update * the data. Could be useful in the event * where we can't make contact to the main server */ #define AICCU_CACHE "/var/cache/aiccu.cache" /* The PID we are running as when daemonized */ #define AICCU_PID "/var/run/aiccu.pid" /* AICCU Configuration file */ #ifdef _WIN32 #define AICCU_CONFIG "C:\\Windows\\aiccu.conf" #else #define AICCU_CONFIG "/etc/aiccu.conf" #endif /* Inbound listen queue */ #define LISTEN_QUEUE 128 /* AICCU Configuration */ struct AICCU_conf { /* used by other parts */ int daemonize; bool verbose; /* Only for AICCU */ char *username; char *password; char *ipv4_interface; char *ipv6_interface; char *tunnel_id; bool automatic; /* Try to be totally automatic? */ bool behindnat; /* Behind a NAT */ struct TIC_conf *tic; /* TIC Structure */ }; /* Global configuration */ extern struct AICCU_conf *g_aiccu; /* AICCU Abstracted Functions */ bool aiccu_InitConfig(void); bool aiccu_LoadConfig(const char *filename); bool aiccu_SaveConfig(const char *filename); void aiccu_FreeConfig(); void aiccu_install(); void aiccu_setup(struct TIC_Tunnel *hTunnel, bool firstrun); void aiccu_reconfig(struct TIC_Tunnel *hTunnel); void aiccu_delete(struct TIC_Tunnel *hTunnel); void aiccu_test(struct TIC_Tunnel *hTunnel, bool automatic); void aiccu_exec(char *fmt, ...); const char *aiccu_license(); #endif /* AICCU_H */ aiccu/common/heartbeat.c0000775000175200017530000001632410120277342012474 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/heartbeat.c - Heartbeat Code *********************************************************** $Author: jeroen $ $Id: heartbeat.c,v 1.4 2004/09/10 10:16:02 jeroen Exp $ $Date: 2004/09/10 10:16:02 $ **********************************************************/ #include "heartbeat.h" #include "aiccu.h" #include #include #include #include #include #include #include #include #if defined(SOL_SOCKET) && defined(SO_BINDTODEVICE) #include #endif /************************************** Functions **************************************/ /* Get a socket and determine the new IP address */ SOCKET heartbeat_socket( int *address_changed, int bStaticTunnel, char *sIPv4Interface, char **sIPv4Local, char *sIPv4POP, char *sIPv4LocalResolve) { SOCKET sockfd; struct sockaddr sa; socklen_t socklen; char local_ipv4[NI_MAXHOST]; #if defined(SOL_SOCKET) && defined(SO_BINDTODEVICE) struct ifreq interface; #endif struct addrinfo hints, *res, *ressave; D(dolog(LOG_DEBUG, "heartbeat_socket() - Address is %s\n", *sIPv4Local)); if (address_changed) *address_changed = 0; /* Get ourselves a nice IPv4 socket */ sockfd = socket(AF_INET, SOCK_DGRAM, 0); if (sockfd < 0) { dolog(LOG_ERR, "Couldn't open a socket for determining current IPv4 address\n"); return -1; } #if defined(SOL_SOCKET) && defined(SO_BINDTODEVICE) /* * We don't have to bind to a device if this * is a static tunnel, this allows running * the heartbeat client as non-root. */ if (!bStaticTunnel) { /* * Only allowed as root, but we need root rights anyways * to (re)configure the tunnel */ /* Bind to the underlying IPv4 device */ memset(&interface, 0, sizeof(interface)); strncpy(interface.ifr_ifrn.ifrn_name, sIPv4Interface, IFNAMSIZ); if (setsockopt(sockfd, SOL_SOCKET, SO_BINDTODEVICE, (char *)&interface, sizeof(interface)) == -1) { dolog(LOG_ERR, "Couldn't bind to device \"%s\"\n", sIPv4Interface); close(sockfd); /* We return a -1, thus the app will keep beating */ return -1; } } #else /* Make compiler happy and 'use' the param */ sIPv4Interface = sIPv4Interface; #endif /* * connect to the remote port * this causes us to be able to use normal write() * and also gives us the ability to find out the local IP */ memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_DGRAM; /* Get the POP IPv4 into a sockaddr */ if (getaddrinfo(sIPv4POP, HEARTBEAT_PORT, &hints, &res) != 0) { dolog(LOG_ERR, "Couldn't resolve POP ip %s\n", sIPv4POP); closesocket(sockfd); /* We return a -1, thus the app will keep beating */ return -1; } ressave = res; while (res) { if (connect(sockfd, res->ai_addr, (unsigned int)res->ai_addrlen) == 0) break; res = res->ai_next; } freeaddrinfo(ressave); if (res == NULL) { dolog(LOG_ERR, "Failed to connect() to remote side\n"); closesocket(sockfd); /* We return a -1, thus the app will keep beating */ return -1; } /* Normal operation, find out our local IPv4 address */ if (sIPv4LocalResolve == NULL) { /* Figure out our local IP */ socklen = sizeof(sa); if (getsockname(sockfd, &sa, &socklen) == -1) { dolog(LOG_WARNING, "Couldn't get local socketaddress\n"); closesocket(sockfd); return -1; } if (getnameinfo((struct sockaddr *)&sa, sizeof(sa), local_ipv4, sizeof(local_ipv4), NULL, 0, NI_NUMERICHOST) != 0) { dolog(LOG_WARNING, "Couldn't get local IP\n"); closesocket(sockfd); return -1; } } else { /* * this causes us to be able to use normal write() * and also gives us the ability to find out the local IP */ memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_DGRAM; /* Get the POP IPv4 into a sockaddr */ if (getaddrinfo(sIPv4LocalResolve, NULL, &hints, &res) != 0) { dolog(LOG_ERR, "Couldn't resolve POP IPv4 %s\n", sIPv4POP); /* We return a -1, thus the app will keep beating */ return -1; } ressave = res; while (res) { if (getnameinfo(res->ai_addr, (socklen_t)res->ai_addrlen, local_ipv4, sizeof(local_ipv4), NULL, 0, NI_NUMERICHOST) == 0) { break; } dolog(LOG_WARNING, "Couldn't get local IP\n"); res = res->ai_next; } freeaddrinfo(ressave); } /* Did the IPv4 address change? */ if (*sIPv4Local == NULL || strcmp(*sIPv4Local, local_ipv4) != 0) { if (*sIPv4Local) free(*sIPv4Local); *sIPv4Local = strdup(local_ipv4); dolog(LOG_DEBUG, "heartbeat_socket() - IPv4 : %s\n", *sIPv4Local); if (!bStaticTunnel) { /* Run a script to change the address */ if (address_changed) *address_changed = 1; } } D(else dolog(LOG_DEBUG, "heartbeat_socket() - Address stays %s\n", *sIPv4Local)); /* Return it */ return sockfd; } /* Send a heartbeat */ int heartbeat_send(SOCKET sockfd, char *sIPv4Local, char *sIPv6Local, char *sPassword, bool bBehindNAT) { struct MD5Context md5; unsigned char *p, our_digest[20], *pn = our_digest, buf[1000]; time_t time_tee; int i; time_tee = time(NULL); /* Create the string to send including our password */ snprintf((char *)buf, sizeof(buf), "HEARTBEAT TUNNEL %s %s %ld %s", sIPv6Local, (bBehindNAT ? "sender" : sIPv4Local), (long int)time_tee, sPassword); /* Generate a MD5 */ MD5Init(&md5); MD5Update(&md5, buf, (unsigned int)strlen((char *)buf)); MD5Final(our_digest, &md5); /* Overwrite it without password */ p = buf; p += snprintf((char *)buf, sizeof(buf)-17, "HEARTBEAT TUNNEL %s %s %ld ", sIPv6Local, (bBehindNAT == 1 ? "sender" : sIPv4Local), (long int)time_tee); /* append the digest */ for (i = 0; i < 16; i++) { snprintf((char *)p, 3, (const char *)"%02x", *pn++); p+=2; } *p = '\0'; /* Send the heartbeat */ send(sockfd, (const char *)buf, (unsigned int)strlen((const char *)buf),0); dolog(LOG_DEBUG, "[HB] %s\n", buf); return 0; } char *heartbeat_getlocalIP(struct TIC_Tunnel *hTunnel) { bool address_changed = false; char *ipv4_local = NULL; SOCKET sockfd = heartbeat_socket(&address_changed, 0, "", &ipv4_local, hTunnel->sIPv4_POP, NULL); if (sockfd >= 0) closesocket(sockfd); dolog(LOG_DEBUG, "Local IPv4 address: %s\n", ipv4_local); return ipv4_local; } /* * Other code can call this every once in a while * and it will take care of everything ("everything?" "everything!") */ void heartbeat_beat(struct TIC_Tunnel *hTunnel) { int address_changed = 0; SOCKET sockfd = -1; D(dolog(LOG_DEBUG, "heartbeat_beat() - Beating from %s\n", hTunnel->sIPv4_Local);) sockfd = heartbeat_socket(&address_changed, 0, "", &hTunnel->sIPv4_Local, hTunnel->sIPv4_POP, NULL); if (sockfd >= 0) { if (address_changed == 1) { D(dolog(LOG_DEBUG, "heartbeat_beat() - Address changed to %s\n", hTunnel->sIPv4_Local);) aiccu_reconfig(hTunnel); } heartbeat_send(sockfd, hTunnel->sIPv4_Local, hTunnel->sIPv6_Local, hTunnel->sPassword, 1); closesocket(sockfd); sockfd = (SOCKET)-1; } } aiccu/common/heartbeat.h0000775000175200017530000000225610115321377012502 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/heartbeat.h - Heartbeat Definitions *********************************************************** $Author: jeroen $ $Id: heartbeat.h,v 1.2 2004/09/01 10:22:55 jeroen Exp $ $Date: 2004/09/01 10:22:55 $ **********************************************************/ #ifndef HEARTBEAT_H #define HEARTBEAT_H "H5K7:W3NDY5UU5N1K1N1C0l3" #include "common.h" #include "tic.h" /* * SixXS Heartbeat Protocol * port - uses UDP over IPv4 */ #define HEARTBEAT_PORT "3740" SOCKET heartbeat_socket( int *address_changed, int bStaticTunnel, char *sIPv4Interface, char **sIPv4Local, char *sIPv4POP, char *sIPv4LocalResolve); int heartbeat_send(SOCKET sockfd, char *sIPv4Local, char *sIPv6Local, char *sPassword, bool bBehindNAT); void heartbeat_beat(struct TIC_Tunnel *hTunnel); char *heartbeat_getlocalIP(struct TIC_Tunnel *hTunnel); #endif /* HEARTBEAT_H */ aiccu/common/aiccu.c0000775000175200017530000002215410115344050011612 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu.c - AICCU Abstracted functions *********************************************************** $Author: jeroen $ $Id: aiccu.c,v 1.3 2004/09/01 13:01:28 jeroen Exp $ $Date: 2004/09/01 13:01:28 $ **********************************************************/ #include "aiccu.h" struct AICCU_conf *g_aiccu = NULL; /* Config */ struct pl_rule aiccu_conf_rules[] = { /* Configuration */ {"username", PLRT_STRING, offsetof(struct AICCU_conf, username)}, {"password", PLRT_STRING, offsetof(struct AICCU_conf, password)}, {"ipv4_interface", PLRT_STRING, offsetof(struct AICCU_conf, ipv4_interface)}, {"ipv6_interface", PLRT_STRING, offsetof(struct AICCU_conf, ipv6_interface)}, {"tunnel_id", PLRT_STRING, offsetof(struct AICCU_conf, tunnel_id)}, /* Automatic */ {"automatic", PLRT_BOOL, offsetof(struct AICCU_conf, automatic)}, /* Operational options */ {"daemonize", PLRT_BOOL, offsetof(struct AICCU_conf, daemonize)}, {"verbose", PLRT_BOOL, offsetof(struct AICCU_conf, verbose)}, {NULL, PLRT_END, 0}, }; bool aiccu_InitConfig() { /* Allocate & Initialize */ g_aiccu = (struct AICCU_conf *)malloc(sizeof(*g_aiccu)); if (!g_aiccu) return false; memset(g_aiccu, 0, sizeof(*g_aiccu)); g_aiccu->tic = (struct TIC_conf *)malloc(sizeof(*g_aiccu->tic)); memset(g_aiccu->tic, 0, sizeof(*g_aiccu->tic)); /* Initialize config to defaults */ g_aiccu->daemonize = -1; g_aiccu->ipv6_interface = strdup("aiccu"); return true; } /* configure this client */ bool aiccu_LoadConfig(const char *filename) { FILE *f; char buf[1000]; unsigned int line = 0; f = fopen(filename, "r"); if (!f) { dolog(LOG_ERR, "Could not open config file \"%s\"\n", filename); return false; } while (fgets(buf, sizeof(buf), f)) { line++; if (parseline(buf, " ", aiccu_conf_rules, g_aiccu)) continue; dolog(LOG_WARNING, "Unknown configuration statement on line %d: \"%s\"\n", line, buf); } fclose(f); return true; } /* Save the configuration */ bool aiccu_SaveConfig(const char *filename) { FILE *f = fopen(filename, "w"); if (!f) { dolog(LOG_ERR, "Could not open config file \"%s\" for writing\n", filename); return false; } fprintf(f, "# AICCU Configuration (Automatically stored by aiccu %s)\n", AICCU_VER); fprintf(f, "\n"); fprintf(f, "# Login information\n"); fprintf(f, "username %s\n", g_aiccu->username); fprintf(f, "password %s\n", g_aiccu->password); fprintf(f, "\n"); fprintf(f, "# Interface names to use\n"); fprintf(f, "ipv4_interface %s\n", g_aiccu->ipv4_interface); fprintf(f, "ipv6_interface %s\n", g_aiccu->ipv6_interface); fprintf(f, "\n"); fprintf(f, "# The tunnel_id to use\n"); fprintf(f, "# (only required when there are multiple tunnels in the list)\n"); fprintf(f, "tunnel_id %s\n", g_aiccu->tunnel_id); fprintf(f, "\n"); fprintf(f, "automatic %s\n", g_aiccu->automatic ? "true" : "false"); fprintf(f, "\n"); fprintf(f, "# Be verbose?\n"); fprintf(f, "verbose %s\n", g_aiccu->verbose ? "true" : "false"); fprintf(f, "\n"); fprintf(f, "# Daemonize?\n"); fprintf(f, "daemonize %s\n", g_aiccu->daemonize ? "true" : "false"); fprintf(f, "\n"); fprintf(f, "# Behind a NAT?\n"); fprintf(f, "behindnat %s\n", g_aiccu->behindnat ? "true" : "false"); fclose(f); return true; } void aiccu_FreeConfig() { if (!g_aiccu) return; if (g_aiccu->username) free(g_aiccu->username); g_aiccu->username = NULL; if (g_aiccu->password) free(g_aiccu->password); g_aiccu->password = NULL; if (g_aiccu->ipv4_interface) free(g_aiccu->ipv4_interface); g_aiccu->ipv4_interface = NULL; if (g_aiccu->ipv6_interface) free(g_aiccu->ipv6_interface); g_aiccu->ipv6_interface = NULL; if (g_aiccu->tunnel_id) free(g_aiccu->tunnel_id); g_aiccu->tunnel_id = NULL; if (g_aiccu->tic) free(g_aiccu->tic); g_aiccu->tic = NULL; free(g_aiccu); g_aiccu = NULL; } /* OS Interfaces - quick and easy */ void aiccu_os_install(); void aiccu_os_setup(struct TIC_Tunnel *hTunnel); void aiccu_os_reconfig(struct TIC_Tunnel *hTunnel); void aiccu_os_delete(struct TIC_Tunnel *hTunnel); void aiccu_os_test(struct TIC_Tunnel *hTunnel, bool automatic); /* Make sure the OS understands IPv6 */ void aiccu_install() { D(dolog(LOG_DEBUG, "aiccu_install()\n");) aiccu_os_install(); } void aiccu_setup(struct TIC_Tunnel *hTunnel, bool firstrun) { D(dolog(LOG_DEBUG, "aiccu_setup(%s, %s)\n", hTunnel->sIPv6_Local, firstrun ? "first" : "other");) /* AYIYA calls aiccu_setup(hTunnel,false) after preparing the tunnel interface */ if (firstrun && strcasecmp(hTunnel->sType, "ayiya") == 0) { ayiya(hTunnel); } else aiccu_os_setup(hTunnel); } void aiccu_reconfig(struct TIC_Tunnel *hTunnel) { D(dolog(LOG_DEBUG, "aiccu_reconfig(%s)\n", hTunnel->sIPv6_Local);) aiccu_os_reconfig(hTunnel); } void aiccu_delete(struct TIC_Tunnel *hTunnel) { D(dolog(LOG_DEBUG, "aiccu_delete(%s)\n", hTunnel->sIPv6_Local);) aiccu_os_delete(hTunnel); } void aiccu_test(struct TIC_Tunnel *hTunnel, bool automatic) { D(dolog(LOG_DEBUG, "aiccu_delete(%s)\n", hTunnel->sIPv6_Local);) aiccu_os_test(hTunnel, automatic); } void aiccu_exec(char *fmt, ...) { #ifndef _WIN32 char buf[1024]; va_list ap; va_start(ap, fmt); vsnprintf(buf,sizeof(buf),fmt,ap); D(dolog(LOG_DEBUG, "aiccu_os_exec(\"%s\")\n", buf)); system(buf); va_end(ap); #endif } #define AICCU_LICENSE_PART1 "\ Copyright (C) SixXS\n\ All rights reserved.\n\ \n\ Redistribution and use in source and binary forms, with or without\n\ modification, are permitted provided that the following conditions\n\ are met:\n\ 1. Redistributions of source code must retain the above copyright\n\ notice, this list of conditions and the following disclaimer.\n" #define AICCU_LICENSE_PART2 "\ 2. Redistributions in binary form must reproduce the above copyright\n\ notice, this list of conditions and the following disclaimer in the\n\ documentation and/or other materials provided with the distribution.\n\ 3. Neither the name of SixXS nor the names of its contributors\n\ may be used to endorse or promote products derived from this software\n\ without specific prior permission.\n" #define AICCU_LICENSE_PART3 "\ 4. One should not remove any reference to, or logo of, SixXS.\n\ 5. When the software is altered to not use SixXS services, one is kindly\n\ asked to notify SixXS of this by sending an email to the SixXS Staff\n\ at info@sixxs.net, containing at least the following details:\n\ 8<--------\n\ Organisation : Organisation Name\n\ Email : mailbox@example.com\n\ Website : http://www.example.com\n\ is using software for:\n" #define AICCU_LICENSE_PART4 "\ <\n\ description of:\n\ the usage\n\ the reason why it was modified\n\ >\n\ -------->8\n\ Additional information details may of course be provided.\n\ We request this to be able to know why people would choose not to\n\ use the services provided by SixXS and the participating ISP's.\n\ \n" #define AICCU_LICENSE_PART5 "\ THIS SOFTWARE IS PROVIDED BY SIXXS AND CONTRIBUTORS ``AS IS'' AND\n\ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n\ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n\ ARE DISCLAIMED. IN NO EVENT SHALL SIXXS OR CONTRIBUTORS BE LIABLE\n\ FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n\ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n" #define AICCU_LICENSE_PART6 "\ OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n\ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n\ LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n\ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n\ SUCH DAMAGE.\n" const char *aiccu_license() { #ifndef NOPEDANTIC /* * Pedantic doesn't allow this long strings, thus we will * play nice and malloc it, copy them in seperatly and * then return the buffer. * What we don't do for compliancy.... */ static char *license = NULL; if (!license) { /* * Make one big block out of it * too bad that the \0's get inserted, * remove them and tada one big text... */ static char l1[] = AICCU_LICENSE_PART1, l2[] = AICCU_LICENSE_PART2, l3[] = AICCU_LICENSE_PART3, l4[] = AICCU_LICENSE_PART4, l5[] = AICCU_LICENSE_PART5, l6[] = AICCU_LICENSE_PART6; unsigned int a = strlen(l1), b = strlen(l2), c = strlen(l3), d = strlen(l4), e = strlen(l5), f = strlen(l6); /* Create the 'long' string our selves then */ license = (char *)malloc(a+b+c+d+e+f); if (!license) return NULL; memcpy(license , l1, a); memcpy(license + a, l2, b); memcpy(license + a + b, l3, c); memcpy(license + a + b + c, l4, d); memcpy(license + a + b + c + d, l5, e); memcpy(license + a + b + c + d + e, l6, f); } return license; #else return AICCU_LICENSE_PART1 AICCU_LICENSE_PART2 AICCU_LICENSE_PART3 AICCU_LICENSE_PART4 AICCU_LICENSE_PART5 AICCU_LICENSE_PART6; #endif } aiccu/common/ayiya.c0000775000175200017530000004100410132757506011652 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/ayiya.c - AYIYA - Anything In Anything *********************************************************** $Author: jeroen $ $Id: ayiya.c,v 1.4 2004/10/12 13:42:30 jeroen Exp $ $Date: 2004/10/12 13:42:30 $ **********************************************************/ #include "aiccu.h" #include "ayiya.h" #include "tic.h" struct pseudo_ayh { struct ayiyahdr ayh; struct in6_addr identity; sha1_byte hash[SHA1_DIGEST_LENGTH]; unsigned char payload[2048]; }; struct in_addr ayiya_ipv4_pop; /* IPv4 remote endpoint */ struct in6_addr ayiya_ipv6_local, /* IPv6 local endpoint */ ayiya_ipv6_pop; /* IPv6 remote endpoint */ sha1_byte ayiya_hash[SHA1_DIGEST_LENGTH]; /* SHA1 Hash of the shared secret. */ /* The tun/tap device HANDLE */ #ifndef _WIN32 int ayiya_fd; #else HANDLE device_handle = INVALID_HANDLE_VALUE; #define ETH_P_IPV6 0x86dd #define ETH_ALEN 6 struct ether_header { u_int8_t ether_dhost[ETH_ALEN]; /* destination eth addr */ u_int8_t ether_shost[ETH_ALEN]; /* source ether addr */ u_int16_t ether_type; /* packet type ID field */ }; #endif SOCKET ayiya_socket = -1; /* Tap device constants which we use */ #define TAP_CONTROL_CODE(request,method) CTL_CODE(FILE_DEVICE_PHYSICAL_NETCARD | 8000, request, method, FILE_ANY_ACCESS) #define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE(6, METHOD_BUFFERED) #define TAP_IOCTL_SET_MEDIA_STATUS TAP_CONTROL_CODE(7, METHOD_BUFFERED) void ayiya_log(int level, struct sockaddr_storage *clientaddr, socklen_t addrlen, const char *fmt, ...) { char buf[1024]; char clienthost[NI_MAXHOST]; char clientservice[NI_MAXSERV]; va_list ap; /* Clear them just in case */ memset(buf, 0, sizeof(buf)); memset(clienthost, 0, sizeof(clienthost)); memset(clientservice, 0, sizeof(clientservice)); if (clientaddr) { int ret; ret = getnameinfo((struct sockaddr *)clientaddr, addrlen, clienthost, sizeof(clienthost), clientservice, sizeof(clientservice), NI_NUMERICHOST|NI_NUMERICSERV); if (ret != 0) { printf("ret: %d, errno: %u, %s\n", ret, errno, strerror(errno)); } } /* Print the host+port this is coming from */ snprintf(buf, sizeof(buf), "[AYIYA]%s%s%s%s : ", clientaddr ? " [" : "", clientaddr ? clienthost : "" , clientaddr ? "]:" : "", clientservice ? clientservice : ""); /* Print the log message behind it */ va_start(ap, fmt); vsnprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), fmt, ap); va_end(ap); /* Actually Log it */ dolog(level, buf); } /* Tap -> Socket */ #ifndef _WIN32 void *ayiya_reader(void *arg) #else DWORD WINAPI ayiya_reader(LPVOID arg) #endif { unsigned char buf[2048]; struct pseudo_ayh *s = (struct pseudo_ayh *)buf, s2; int lenout; SHA_CTX sha1; sha1_byte hash[SHA1_DIGEST_LENGTH]; struct sockaddr_in target; #ifdef _WIN32 DWORD n; OVERLAPPED overlapped; /* Create an event for overlapped results */ overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); #else ssize_t n; /* use the param and let gcc not complain */ arg = NULL; #endif ayiya_log(LOG_INFO, NULL, 0, "Writer (TAP to Socket) started\n"); while (true) { /* We tunnel over IPv4 */ memcpy(&target.sin_addr, &ayiya_ipv4_pop, sizeof(target.sin_addr)); target.sin_family = AF_INET; target.sin_port = htons(atoi(AYIYA_PORT)); /* Prefill some standard AYIYA values */ memset(&s, 0, sizeof(s)); s2.ayh.ayh_idlen = 4; /* 2^4 = 16 bytes = 128 bits (IPv6 address) */ s2.ayh.ayh_idtype = ayiya_id_integer; s2.ayh.ayh_siglen = 5; /* 5*4 = 20 bytes = 160 bits (SHA1) */ s2.ayh.ayh_hshmeth = ayiya_hash_sha1; s2.ayh.ayh_autmeth = ayiya_auth_sharedsecret; s2.ayh.ayh_opcode = ayiya_op_forward; s2.ayh.ayh_nextheader = IPPROTO_IPV6; /* Our IPv6 side of this tunnel */ memcpy(&s2.identity, &ayiya_ipv6_local, sizeof(s2.identity)); #ifndef _WIN32 n = read(ayiya_fd, s2.payload, sizeof(s2.payload)); if (n <= 0) { ayiya_log(LOG_ERR, NULL, 0, "[writer] Error reading from device (%d): %s\n", errno, strerror(errno)); continue; } #ifndef DARWIN if (s2.payload[2] != 0x86 || s2.payload[3] != 0xdd) { ayiya_log(LOG_ERR, NULL, 0, "[writer] Ignoring %02x%02x packet\n", s2.payload[2], s2.payload[3]); continue; } /* get the tun_pi struct out of there */ memmove(&s2.payload, &s2.payload[4], n-4); #endif #else overlapped.Offset = 0; overlapped.OffsetHigh = 0; ResetEvent(overlapped.hEvent); n = ReadFile(device_handle, s2.payload, sizeof(s2.payload), &n, &overlapped); if (!n) { if (GetLastError() == ERROR_IO_PENDING) { WaitForSingleObject(overlapped.hEvent, INFINITE); if (!GetOverlappedResult(device_handle, &overlapped, &n, FALSE)) continue; } else { ayiya_log(LOG_ERR, NULL, 0, "[writer] Error reading from device (%d): %s\n", errno, strerror(errno)); continue; } } #endif /* Fill in the current time */ s2.ayh.ayh_epochtime = htonl((u_long)time(NULL)); /* * The hash of the shared secret needs to be in the * spot where we later put the complete hash */ memcpy(&s2.hash, ayiya_hash, sizeof(s2.hash)); /* Generate a SHA1 */ SHA1_Init(&sha1); /* Hash the complete AYIYA packet */ SHA1_Update(&sha1, (sha1_byte *)&s2, sizeof(s2)-sizeof(s2.payload)+n); /* Store the hash in the packets hash */ SHA1_Final(hash, &sha1); /* Store the hash in the actual packet */ memcpy(&s2.hash, &hash, sizeof(s2.hash)); /* Send it onto the network */ n = sizeof(s2)-sizeof(s2.payload)+n; #ifndef DARWIN lenout = sendto(ayiya_socket, (const char *)&s2, (unsigned int)n, 0, (struct sockaddr *)&target, sizeof(target)); #else lenout = sendto(ayiya_socket, (const char *)&s2, (unsigned int)n, 0); #endif if (lenout < 0) { ayiya_log(LOG_ERR, NULL, 0, "[writer] Error (%d) while sending %u bytes sent to network (%d): %s)\n", lenout, n, errno, strerror(errno)); } else if (n != lenout) { ayiya_log(LOG_ERR, NULL, 0, "[writer] Only %u of %u bytes sent to network (%d): %s)\n", lenout, n, errno, strerror(errno)); } } #ifndef _WIN32 return NULL; #else return 0; #endif } /* Socket -> Tap */ #ifndef _WIN32 void *ayiya_writer(void *arg) #else DWORD WINAPI ayiya_writer(LPVOID arg) #endif { unsigned char buf[2048]; struct pseudo_ayh *s = (struct pseudo_ayh *)buf; struct sockaddr_storage ci; socklen_t cl; int i, n; unsigned int payloadlen = 0; SHA_CTX sha1; sha1_byte their_hash[SHA1_DIGEST_LENGTH], our_hash[SHA1_DIGEST_LENGTH]; #ifdef _WIN32 DWORD lenout; OVERLAPPED overlapped = {0}; #else /* use the param and let gcc not complain */ arg = NULL; #endif ayiya_log(LOG_INFO, NULL, 0, "Reader (Socket to TAP) started\n"); while (true) { cl = sizeof(ci); memset(buf, 0, sizeof(buf)); n = recvfrom(ayiya_socket, (char *)buf, sizeof(buf), 0, (struct sockaddr *)&ci, &cl); if (n < 0) continue; if (n < (int)sizeof(struct ayiyahdr)) { ayiya_log(LOG_WARNING, &ci, cl, "[reader] Packet too short"); continue; } if ( s->ayh.ayh_idlen != 4 || s->ayh.ayh_idtype != ayiya_id_integer || s->ayh.ayh_siglen != 5 || s->ayh.ayh_hshmeth != ayiya_hash_sha1 || s->ayh.ayh_autmeth != ayiya_auth_sharedsecret || (s->ayh.ayh_nextheader != IPPROTO_IPV6 && s->ayh.ayh_nextheader != IPPROTO_NONE) || (s->ayh.ayh_opcode != ayiya_op_forward && s->ayh.ayh_opcode != ayiya_op_echo_request && s->ayh.ayh_opcode != ayiya_op_echo_request_forward)) { /* Invalid AYIYA packet */ ayiya_log(LOG_ERR, &ci, cl, "Dropping invalid AYIYA packet\n"); ayiya_log(LOG_ERR, &ci, cl, "idlen: %u != %u\n", s->ayh.ayh_idlen, 4); ayiya_log(LOG_ERR, &ci, cl, "idtype: %u != %u\n", s->ayh.ayh_idtype, ayiya_id_integer); ayiya_log(LOG_ERR, &ci, cl, "siglen: %u != %u\n", s->ayh.ayh_siglen, 5); ayiya_log(LOG_ERR, &ci, cl, "hshmeth: %u != %u\n", s->ayh.ayh_hshmeth, ayiya_hash_sha1); ayiya_log(LOG_ERR, &ci, cl, "autmeth: %u != %u\n", s->ayh.ayh_autmeth, ayiya_auth_sharedsecret); ayiya_log(LOG_ERR, &ci, cl, "nexth : %u != %u || %u\n", s->ayh.ayh_nextheader, IPPROTO_IPV6, IPPROTO_NONE); ayiya_log(LOG_ERR, &ci, cl, "opcode : %u != %u || %u || %u\n", s->ayh.ayh_opcode, ayiya_op_forward, ayiya_op_echo_request, ayiya_op_echo_request_forward); continue; } if (memcmp(&s->identity, &ayiya_ipv6_pop, sizeof(s->identity)) != 0) { memset(buf, 0, sizeof(buf)); inet_ntop(AF_INET6, &s->identity, (char *)&buf, sizeof(buf)); ayiya_log(LOG_WARNING, &ci, cl, "[reader] Received packet from a wrong identity \"%s\"\n", buf); continue; } /* Verify the epochtime */ i = tic_checktime(ntohl(s->ayh.ayh_epochtime)); if (i != 0) { memset(buf, 0, sizeof(buf)); inet_ntop(AF_INET6, &s->identity, (char *)&buf, sizeof(buf)); ayiya_log(LOG_WARNING, &ci, cl, "[reader] Time is %d seconds off for %s\n", i, buf); continue; } /* How long is the payload? */ payloadlen = n - (sizeof(*s) - sizeof(s->payload)); /* Save their hash */ memcpy(&their_hash, &s->hash, sizeof(their_hash)); /* Copy in our SHA1 hash */ memcpy(&s->hash, &ayiya_hash, sizeof(s->hash)); /* Generate a SHA1 of the header + identity + shared secret */ SHA1_Init(&sha1); /* Hash the Packet */ SHA1_Update(&sha1, (sha1_byte *)s, n); /* Store the hash */ SHA1_Final(our_hash, &sha1); memcpy(&s->hash, &our_hash, sizeof(s->hash)); /* Compare the SHA1's */ if (memcmp(&their_hash, &our_hash, sizeof(their_hash)) != 0) { ayiya_log(LOG_WARNING, &ci, cl, "[reader] Incorrect Hash received\n"); continue; } if (s->ayh.ayh_nextheader == IPPROTO_IPV6) { /* Verify that this is really IPv6 */ if (s->payload[0] >> 4 != 6) { ayiya_log(LOG_ERR, &ci, cl, "[reader] Received packet didn't start with a 6, thus is not IPv6\n"); continue; } /* Forward the packet to the kernel */ #ifndef _WIN32 { unsigned int c; #ifdef linux struct { struct tun_pi pi; char payload[2048]; } packet; memset(&packet, 0, sizeof(packet)); packet.pi.proto = htons(ETH_P_IPV6); memcpy(&packet.payload, &s->payload, payloadlen); /* Forward the packet to the kernel */ c = write(ayiya_fd, &packet, payloadlen+sizeof(struct tun_pi)); if (c != payloadlen+sizeof(struct tun_pi)) { ayiya_log(LOG_ERR, &ci, cl, "[writer] Error while writing to TAP: %u != %u\n", c, payloadlen+sizeof(struct tun_pi)); } #else c = write(ayiya_fd, &s->payload, payloadlen); if (c != payloadlen) { ayiya_log(LOG_ERR, &ci, cl, "[writer] Error while writing to TAP: %u != %u\n", c, payloadlen); } #endif } #else if (!WriteFile(device_handle, &s->payload, payloadlen, &lenout, &overlapped)) { ayiya_log(LOG_ERR, &ci, cl, "[writer] Error while writing to TAP\n"); } #endif } } #ifndef _WIN32 return NULL; #else return 0; #endif } bool ayiya(struct TIC_Tunnel *hTunnel) { SHA_CTX sha1; struct addrinfo hints, *res, *ressave; #ifndef _WIN32 pthread_t thread; #ifdef linux struct ifreq ifr; /* Create a new tap device */ ayiya_fd = open("/dev/net/tun", O_RDWR); if (ayiya_fd == -1) { ayiya_log(LOG_ERR, NULL, 0, "Couldn't open device %s (%d): %s\n", "/dev/net/tun", errno, strerror(errno)); return false; } memset(&ifr, 0, sizeof(ifr)); /* Request a TUN device */ ifr.ifr_flags = IFF_TUN; /* Set the interface name */ strncpy(ifr.ifr_name, g_aiccu->ipv6_interface, sizeof(ifr.ifr_name)); if (ioctl(ayiya_fd, TUNSETIFF, &ifr)) { ayiya_log(LOG_ERR, NULL, 0, "Couldn't set interface name to %s (%d): %s\n", g_aiccu->ipv6_interface, errno, strerror(errno)); return false; } #else int i; ayiya_fd = -1; for (i = 0; i < 256; ++i) { char buf[128]; snprintf(buf, sizeof(buf), "/dev/tun%d", i); ayiya_fd = open(buf, O_RDWR); if (ayiya_fd >= 0) { break; } } if (ayiya_fd < 0) { ayiya_log(LOG_ERR, NULL, 0, "Couldn't open device %s (%d): %s\n", "/dev/tun", errno, strerror(errno)); return false; } #endif /* linux */ #else HKEY key; DWORD pID; HANDLE h; int i; char adapterid[1024]; char tapname[1024]; DWORD len; unsigned long status; /* Open registry and look for network adapters */ if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Network\\{4D36E972-E325-11CE-BFC1-08002BE10318}", 0, KEY_READ, &key)) { ayiya_log(LOG_ERR, NULL, 0, "Could not open the networking registry key\n"); return false; } for (i = 0; device_handle == INVALID_HANDLE_VALUE; i++) { len = sizeof(adapterid); if (RegEnumKeyEx(key, i, adapterid, &len, 0, 0, 0, NULL)) break; snprintf(tapname, sizeof(tapname), "\\\\.\\%s.tap", adapterid); ayiya_log(LOG_DEBUG, NULL, 0, "Trying %s\n", tapname); device_handle = CreateFile(tapname, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0); } RegCloseKey(key); if (device_handle == INVALID_HANDLE_VALUE) { ayiya_log(LOG_ERR, NULL, 0, "No Tap device found!\n"); return false; } status = true; DeviceIoControl(device_handle, TAP_IOCTL_SET_MEDIA_STATUS, &status, sizeof(status), &status, sizeof(status), &len, NULL); { u_int32_t ep[2]; /* Use bogus IP's, we just want to get configured as PtP ;) */ ep[0] = htonl(0x09044504); ep[1] = htonl(0x09044505); if (!DeviceIoControl(device_handle, TAP_IOCTL_CONFIG_POINT_TO_POINT, ep, sizeof(ep), ep, sizeof(ep), &len, NULL)) { ayiya_log(LOG_ERR, NULL, 0, "Could not set point to point mode..."); return false; } } #endif /* _WIN32 */ /* Resolve hTunnel entries */ memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_DGRAM; if (getaddrinfo(hTunnel->sIPv4_POP, AYIYA_PORT, &hints, &res) != 0) { dolog(LOG_ERR, "Couldn't resolve POP IPv4 %s\n", hTunnel->sIPv4_POP); return false; } ressave = res; while (res) { if (res->ai_family != AF_INET) { res = res->ai_next; continue; } memcpy(&ayiya_ipv4_pop, &((struct sockaddr_in *)res->ai_addr)->sin_addr, 4); break; } freeaddrinfo(ressave); if (res == NULL) { dolog(LOG_ERR, "No valid IPv4 address for POP address %s could be found\n", hTunnel->sIPv4_POP); return false; } memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_INET6; if (getaddrinfo(hTunnel->sIPv6_Local, NULL, &hints, &res) != 0) { dolog(LOG_ERR, "Couldn't resolve Local IPv6 %s\n", hTunnel->sIPv6_Local); return false; } ressave = res; while (res) { if (res->ai_family != AF_INET6) { res = res->ai_next; continue; } memcpy(&ayiya_ipv6_local, &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr, 16); break; } freeaddrinfo(ressave); if (res == NULL) { dolog(LOG_ERR, "No valid IPv6 address for Local IPv6 address %s could be found\n", hTunnel->sIPv6_Local); return false; } memset(&hints, 0, sizeof(struct addrinfo)); hints.ai_family = AF_INET6; if (getaddrinfo(hTunnel->sIPv6_POP, NULL, &hints, &res) != 0) { dolog(LOG_ERR, "Couldn't resolve Local IPv6 %s\n", hTunnel->sIPv6_POP); return false; } ressave = res; while (res) { if (res->ai_family != AF_INET6) { res = res->ai_next; continue; } memcpy(&ayiya_ipv6_pop, &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr, 16); break; } freeaddrinfo(ressave); if (res == NULL) { dolog(LOG_ERR, "No valid IPv6 address for POP IPv6 address %s could be found\n", hTunnel->sIPv6_POP); return false; } if (!hTunnel->sPassword) { dolog(LOG_ERR, "A password is required for using AYIYA tunnels\n"); return false; } /* Generate a SHA1 of the shared secret */ SHA1_Init(&sha1); SHA1_Update(&sha1, (const sha1_byte *)hTunnel->sPassword, (unsigned int)strlen(hTunnel->sPassword)); SHA1_Final(ayiya_hash, &sha1); /* Setup listening socket */ ayiya_socket = connect_client(hTunnel->sIPv4_POP , AYIYA_PORT, AF_INET, SOCK_DGRAM); if (ayiya_socket == -1) { ayiya_log(LOG_ERR, NULL, 0, "Connection error:: could not create connection to AYIYA server\n"); return false; } /* Let AICCU configure the thing */ aiccu_setup(hTunnel, false); /* Show that we have started */ ayiya_log(LOG_INFO, NULL, 0, "Anything in Anything (%s)\n", AYIYA_VERSION); /* Launch a thread for reader */ #ifndef _WIN32 pthread_create(&thread, NULL, ayiya_reader, NULL); #else h = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ayiya_reader, NULL, 0, &pID); #endif /* The writer takes over this thread and thus keeps running */ ayiya_writer(NULL); return false; } aiccu/common/tic.c0000775000175200017530000003506010115321377011314 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/tic.h - Tunnel Information & Control Protocol *********************************************************** $Author: jeroen $ $Id: tic.c,v 1.2 2004/09/01 10:22:55 jeroen Exp $ $Date: 2004/09/01 10:22:55 $ **********************************************************/ #include "common.h" #include "aiccu.h" #include "tic.h" /* Specific includes only used here */ #ifndef _WIN32 #include #endif /* getline vars */ char tic_buf[2048]; unsigned int tic_filled; /* * epochtime = epochtime as received in the packet * Don't forget to convert byteorder using ntohl() */ int tic_checktime(time_t epochtime) { /* Number of seconds we allow the clock to be off */ #define CLOCK_OFF 120 int i; /* Get the current time */ time_t curr_time = time(NULL); /* Is one of the times in the loop range? */ if ( (curr_time >= -CLOCK_OFF) || (epochtime >= -CLOCK_OFF)) { /* Shift the times out of the loop range */ i =(int)(((int)curr_time) + (CLOCK_OFF*2)) - (((int)epochtime) + (CLOCK_OFF*2)); } else i = ((int)curr_time) - ((int)epochtime); /* The clock may be faster, thus flip the sign */ if (i < 0) i = -i; /* Compare the clock offset */ if (i > CLOCK_OFF) { /* Time is off */ return i; } /* Time is in the allowed range */ return 0; } bool tic_Login(struct TIC_conf *tic, char *username, char *password) { char buf[1024], sSignature[33], sChallenge[1024]; int i; #ifndef _WIN32 struct utsname utsname; #else OSVERSIONINFO osv; OSVERSIONINFOEX osvEx; char *platform = NULL; char version[100]; #endif /* Connect to the TIC server */ tic->sock = connect_client(TIC_SERVER, TIC_PORT, AF_INET, SOCK_STREAM); if (tic->sock == -1) { dolog(LOG_ERR, "Couldn't connect to the TIC server\n"); return false; } /* Fetch the welcome */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { return false; } if (buf[0] != '2') { dolog(LOG_ERR, "TIC Server is currently not available\n"); return false; } /* Send our client identification */ #ifndef _WIN32 uname(&utsname); sock_printf(tic->sock, "client TIC/%s %s/%s %s/%s\n", TIC_VERSION, TIC_CLIENT_NAME, TIC_CLIENT_VERSION, utsname.sysname, utsname.release); #else osv.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); osvEx.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX); if (!GetVersionEx(&osv)) { platform = "Windows"; snprintf(version, sizeof(version), "%s", "Unknown"); } else { platform = (osv.dwPlatformId == VER_PLATFORM_WIN32s) ? "Win32s" : ((osv.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) ? "Win9x" : ((osv.dwPlatformId == VER_PLATFORM_WIN32_NT) ? "WinNT" : "Windows")); if ( osv.dwMajorVersion < 5 || !GetVersionEx((OSVERSIONINFO *)&osvEx) || osvEx.wServicePackMajor <= 0) { snprintf(version, sizeof(version), "%d.%d.%d", osv.dwMajorVersion, osv.dwMinorVersion, osv.dwBuildNumber); } else if (osvEx.wServicePackMinor <= 0) { snprintf(version, sizeof(version), "%d.%d.%d-SP%d", osv.dwMajorVersion, osv.dwMinorVersion, osv.dwBuildNumber, osvEx.wServicePackMajor); } else { snprintf(version, sizeof(version), "%d.%d.%d-SP%d.%d", osv.dwMajorVersion, osv.dwMinorVersion, osv.dwBuildNumber, osvEx.wServicePackMajor, osvEx.wServicePackMinor); } } sock_printf(tic->sock, "client TIC/%s %s/%s %s/%s\n", TIC_VERSION, TIC_CLIENT_NAME, TIC_CLIENT_VERSION, platform, version); #endif /* Fetch the answer */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { return false; } if (buf[0] != '2') { dolog(LOG_ERR, "Couldn't pass client information: %s.\n", &buf[4]); return false; } /* Request current time */ sock_printf(tic->sock, "get unixtime\n"); /* Fetch the answer */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { return false; } if (buf[0] != '2') { dolog(LOG_ERR, "Time not available? %s\n", &buf[4]); return false; } /* Check if the time is correct */ i = tic_checktime(atoi(&buf[4])); if (i != 0) { dolog(LOG_ERR, "The clock is off by %d seconds, use NTP to sync it!\n", i); return false; } /* Send our username */ sock_printf(tic->sock, "username %s\n", username); /* Fetch the answer */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { return false; } if (buf[0] != '2') { dolog(LOG_ERR, "Username not accepted: %s.\n", &buf[4]); return false; } /* Pick a challenge */ sock_printf(tic->sock, "challenge md5\n"); /* Fetch the answer */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { return false; } if (buf[0] != '2') { dolog(LOG_ERR, "Challenge not correct: %s.\n", &buf[4]); return false; } /* Send the response */ /* sSignature = md5(challenge.md5(password)); */ MD5String(password, sSignature, sizeof(sSignature)); snprintf(sChallenge, sizeof(sChallenge), "%s%s", &buf[4], sSignature); MD5String(sChallenge, sSignature, sizeof(sSignature)); sock_printf(tic->sock, "authenticate md5 %s\n", sSignature); /* Fetch the answer */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { tic_Logout(tic); return false; } if (buf[0] != '2') { tic_Logout(tic); dolog(LOG_ERR, "Response not accepted: %s.\n", &buf[4]); return false; } /* Connect OK */ return true; } void tic_Logout(struct TIC_conf *tic) { const char *byers[] = { "Tschau!", "Zij die gaan, groeten u", "See you later alligator", "A bitter thought, but I have to go", "This is not our farewell", "Something I can never have", "Ajuuu paraplu", "Thank you for the information", "It was lovely talking to you again", "And All That Could Have Been...", "Running Down That Hill", "Tschussss...", "Aufwiedersehen", "I'll be back. Ha, you didn't know I was going to say that!", "We will be the only two people left in the world, Yes--Adam and Evil!", }; /* Already disconnected? */ if (tic->sock == -1) return; /* Stupid random quit messages, got to put some form of easteregg in it :) */ srand((unsigned)time(NULL)); /* Send our bye bye */ sock_printf(tic->sock, "QUIT %s\n", byers[rand()%(sizeof(byers)/sizeof(char *))]); /* Disconnect */ closesocket(tic->sock); tic->sock = -1; } struct TIC_sTunnel *tic_ListTunnels(struct TIC_conf *tic) { char buf[1024], buf2[1024]; struct TIC_sTunnel *start = NULL, *last = NULL, *tun = NULL; int i; /* Request a list of Tunnels */ sock_printf(tic->sock, "tunnel list\n"); /* Fetch the answer */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { return NULL; } /* 201 (start of list) ? */ if (buf[0] != '2' || buf[1] != '0' || buf[2] != '1') { dolog(LOG_ERR, "Couldn't list tunnels: %s.\n", &buf[4]); return NULL; } /* Process all the lines */ while (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) != -1) { /* 202 (end of list) ? */ if (buf[0] == '2' && buf[1] == '0' && buf[2] == '2') break; i = countfields(buf); if (i != 4) { dolog(LOG_ERR, "Wrong field format when listing tunnels\n"); break; } /* Allocate a new struct */ tun = (struct TIC_sTunnel *)malloc(sizeof(*tun)); if (!tun) { dolog(LOG_ERR, "Memory problem while listing tunnels\n"); break; } memset(tun, 0, sizeof(*tun)); /* Copy the fields into the struct */ if (!copyfield(buf, 1, buf2, sizeof(buf2))) break; tun->sId = strdup(buf2); if (!copyfield(buf, 2, buf2, sizeof(buf2))) break; tun->sIPv6 = strdup(buf2); if (!copyfield(buf, 3, buf2, sizeof(buf2))) break; tun->sIPv4 = strdup(buf2); if (!copyfield(buf, 4, buf2, sizeof(buf2))) break; tun->sPOPId = strdup(buf2); /* Add it into the list */ if (last) { last->next = tun; last = tun; } else { start = last = tun; } } /* All went okay? */ if (buf[0] == '2' && buf[1] == '0' && buf[2] == '2') { return start; } /* Free the structure, it was broken anyway */ tic_Free_sTunnel(start); dolog(LOG_ERR, "Tunnel list went wrong: %s\n", &buf[4]); return NULL; } struct TIC_sRoute *tic_ListRoutes(struct TIC_conf *tic) { dolog(LOG_ERR, "Not implemented - tic_ListRoutes(%x)\n", tic); return NULL; } struct TIC_sPOP *tic_ListPOPs(struct TIC_conf *tic) { dolog(LOG_ERR, "Not implemented - tic_ListPOPs(%x)\n", tic); return NULL; } struct pl_rule tunnel_rules[] = { {"TunnelId", PLRT_STRING, offsetof(struct TIC_Tunnel, sId)}, {"Type", PLRT_STRING, offsetof(struct TIC_Tunnel, sType)}, {"IPv6 Endpoint", PLRT_STRING, offsetof(struct TIC_Tunnel, sIPv6_Local)}, {"IPv6 POP", PLRT_STRING, offsetof(struct TIC_Tunnel, sIPv6_POP)}, {"IPv6 PrefixLength", PLRT_INTEGER, offsetof(struct TIC_Tunnel, nIPv6_PrefixLength)}, {"POP Id", PLRT_STRING, offsetof(struct TIC_Tunnel, sPOP_Id)}, {"IPv4 Endpoint", PLRT_STRING, offsetof(struct TIC_Tunnel, sIPv4_Local)}, {"IPv4 POP", PLRT_STRING, offsetof(struct TIC_Tunnel, sIPv4_POP)}, {"UserState", PLRT_STRING, offsetof(struct TIC_Tunnel, sUserState)}, {"AdminState", PLRT_STRING, offsetof(struct TIC_Tunnel, sAdminState)}, {"Password", PLRT_STRING, offsetof(struct TIC_Tunnel, sPassword)}, {"Heartbeat_Interval", PLRT_INTEGER, offsetof(struct TIC_Tunnel, nHeartbeat_Interval)}, {NULL, PLRT_END, 0}, }; struct TIC_Tunnel *tic_GetTunnel(struct TIC_conf *tic, char *sId) { char buf[1024]; struct TIC_Tunnel *tun; /* Get a Tunnel */ sock_printf(tic->sock, "tunnel show %s\n", sId); /* Fetch the answer */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { return NULL; } /* 201 (start of information) ? */ if (buf[0] != '2' || buf[1] != '0' || buf[2] != '1') { dolog(LOG_ERR, "Couldn't show tunnel %s: %s.\n", sId, buf); return NULL; } /* Allocate a new struct */ tun = (struct TIC_Tunnel *)malloc(sizeof(*tun)); if (!tun) { dolog(LOG_ERR, "Memory problem while getting tunnel %s\n", sId); return NULL; } memset(tun, 0, sizeof(*tun)); /* Gather the information */ while (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) != -1) { /* 202 (end of list) ? */ if (buf[0] == '2' && buf[1] == '0' && buf[2] == '2') break; parseline(buf, ": ", tunnel_rules, tun); } /* All went okay? */ if (buf[0] == '2' && buf[1] == '0' && buf[2] == '2') { dolog(LOG_INFO, "Succesfully retrieved tunnel information for %s\n", sId); return tun; } /* Free the structure, it is broken anyway */ tic_Free_Tunnel(tun); dolog(LOG_ERR, "Tunnel Get for %s went wrong: %s\n", sId, buf); return NULL; } struct TIC_Route *tic_GetRoute(struct TIC_conf *tic, char *sId) { dolog(LOG_ERR, "Not implemented - tic_GetRoute(%x, \"%s\")\n", tic, sId); return NULL; } struct pl_rule pop_rules[] = { {"POPId", PLRT_STRING, offsetof(struct TIC_POP, sId)}, {"City", PLRT_STRING, offsetof(struct TIC_POP, sCity)}, {"Country", PLRT_STRING, offsetof(struct TIC_POP, sCountry)}, {"IPv4", PLRT_STRING, offsetof(struct TIC_POP, sIPv4)}, {"IPv6", PLRT_STRING, offsetof(struct TIC_POP, sIPv6)}, {"ISP Short", PLRT_STRING, offsetof(struct TIC_POP, sISP_Short)}, {"ISP Name", PLRT_STRING, offsetof(struct TIC_POP, sISP_Name)}, {"ISP Website", PLRT_STRING, offsetof(struct TIC_POP, sISP_Website)}, {"ISP ASN", PLRT_STRING, offsetof(struct TIC_POP, sISP_ASN)}, {"ISP LIR", PLRT_STRING, offsetof(struct TIC_POP, sISP_LIR)}, {NULL, PLRT_END, 0}, }; struct TIC_POP *tic_GetPOP(struct TIC_conf *tic, char *sId) { char buf[1024]; struct TIC_POP *pop; /* Get a Tunnel */ sock_printf(tic->sock, "pop show %s\n", sId); /* Fetch the answer */ if (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) == -1) { return NULL; } /* 201 (start of info) ? */ if (buf[0] != '2' || buf[1] != '0' || buf[2] != '1') { dolog(LOG_ERR, "Couldn't show POP %s: %s.\n", sId, buf); return NULL; } /* Allocate a new struct */ pop = (struct TIC_POP *)malloc(sizeof(*pop)); if (!pop) { dolog(LOG_ERR, "Memory problem while getting POP\n"); return NULL; } memset(pop, 0, sizeof(*pop)); /* Gather the information */ while (sock_getline(tic->sock, tic_buf, sizeof(tic_buf), &tic_filled, buf, sizeof(buf)) != -1) { /* 202 (end of list) ? */ if (buf[0] == '2' && buf[1] == '0' && buf[2] == '2') break; parseline(buf, ": ", pop_rules, pop); } /* All went okay? */ if (buf[0] == '2' && buf[1] == '0' && buf[2] == '2') { dolog(LOG_INFO, "Succesfully retrieved POP information for %s\n", sId); return pop; } /* Free the structure, it is broken anyway */ tic_Free_POP(pop); dolog(LOG_ERR, "POP Get for %s went wrong: %s\n", sId, buf); return NULL; } void tic_Free_sTunnel(struct TIC_sTunnel *tun) { struct TIC_sTunnel *next; for (; tun; tun = next) { next = tun->next; if (tun->sId) free(tun->sId); if (tun->sIPv6) free(tun->sIPv6); if (tun->sIPv4) free(tun->sIPv4); if (tun->sPOPId) free(tun->sPOPId); free(tun); } } void tic_Free_sRoute(struct TIC_sRoute *rt) { struct TIC_sRoute *next; for (; rt; rt = next) { next = rt->next; if (rt->sId) free(rt->sId); if (rt->sTunnelId) free(rt->sTunnelId); if (rt->sIPv6) free(rt->sIPv6); free(rt); } } void tic_Free_sPOP(struct TIC_sPOP *pop) { struct TIC_sPOP *next; for (; pop; pop = next) { next = pop->next; if (pop->sId) free(pop->sId); free(pop); } } void tic_Free_Tunnel(struct TIC_Tunnel *tun) { if (tun->sId) free(tun->sId); if (tun->sType) free(tun->sType); if (tun->sPOP_Id) free(tun->sPOP_Id); if (tun->sUserState) free(tun->sUserState); if (tun->sAdminState) free(tun->sAdminState); if (tun->sPassword) free(tun->sPassword); if (tun->sIPv4_Local) free(tun->sIPv4_Local); if (tun->sIPv4_POP) free(tun->sIPv4_POP); if (tun->sIPv6_Local) free(tun->sIPv6_Local); if (tun->sIPv6_POP) free(tun->sIPv6_POP); free(tun); } void tic_Free_Route(struct TIC_Route *rt) { if (rt->sId) free(rt->sId); if (rt->sTunnelId) free(rt->sTunnelId); free(rt); } void tic_Free_POP(struct TIC_POP *pop) { if (pop->sId) free(pop->sId); if (pop->sCity) free(pop->sCity); if (pop->sCountry) free(pop->sCountry); if (pop->sIPv4) free(pop->sIPv4); if (pop->sIPv6) free(pop->sIPv6); if (pop->sISP_Short) free(pop->sISP_Short); if (pop->sISP_Name) free(pop->sISP_Name); if (pop->sISP_Website) free(pop->sISP_Website); if (pop->sISP_ASN) free(pop->sISP_ASN); if (pop->sISP_LIR) free(pop->sISP_LIR); free(pop); } aiccu/common/tic.h0000775000175200017530000000770210115321377011323 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/tic.h - Tunnel Information & Control Protocol *********************************************************** $Author: jeroen $ $Id: tic.h,v 1.2 2004/09/01 10:22:55 jeroen Exp $ $Date: 2004/09/01 10:22:55 $ **********************************************************/ #ifndef TIC_H #define TIC_H "H5K7:W3NDY5UU5N1K1N1C0l3" #include "common.h" /* * Tunnel Information Control Protocol * server */ #define TIC_SERVER "tic.sixxs.net" /* port - uses TCP over IPv4 */ #define TIC_PORT "3874" /* TIC version (which document this should conform to) */ #define TIC_VERSION "draft-00" struct TIC_sTunnel { struct TIC_sTunnel *next; /* Next in list */ char *sId; /* Tunnel Id */ char *sIPv6; /* Local IPv6 Endpoint */ char *sIPv4; /* Local IPv4 Endpoint */ char *sPOPId; /* POP Id */ }; struct TIC_Tunnel { char *sId; /* Tunnel Id */ char *sType; /* Tunnel Type */ /* IPv4 information */ char *sIPv4_Local; /* Local endpoint (*) */ char *sIPv4_POP; /* POP endpoint */ /* IPv6 information */ char *sIPv6_Local; /* Local endpoint */ char *sIPv6_POP; /* POP endpoint */ unsigned int nIPv6_PrefixLength; /* Length of the prefix's */ /* POP information */ char *sPOP_Id; /* POP's Id */ /* States */ char *sUserState; /* Userstate */ char *sAdminState; /* Adminstate */ /* AYIYA & Heartbeat */ char *sPassword; /* Password for the tunnel */ int nHeartbeat_Interval; /* Heartbeat interval */ }; /* * = 0.0.0.0 for all the dynamic tunnels */ struct TIC_sRoute { struct TIC_sRoute *next; /* Next in list */ char *sId; /* Route Id */ char *sTunnelId; /* Tunnel Id */ char *sIPv6; /* Prefix */ }; struct TIC_Route { char *sId; /* Route Id */ char *sTunnelId; /* Tunnel Id */ struct in6_addr xIPv6; /* Prefix */ unsigned int nPrefixLength; /* Length of the prefix */ }; struct TIC_sPOP { struct TIC_sPOP *next; /* Next in list */ char *sId; /* POP's Id */ }; struct TIC_POP { char *sId; /* POP's Id */ char *sCity; /* POP's City */ char *sCountry; /* POP's Country */ char *sIPv4; /* POP's Primary IPv4 address */ char *sIPv6; /* POP's Primary IPv6 address */ char *sISP_Short; /* ISP's Short name */ char *sISP_Name; /* ISP's Name */ char *sISP_Website; /* ISP's Website */ char *sISP_ASN; /* ISP's ASN */ char *sISP_LIR; /* ISP's LIR */ }; /* * This structure makes TIC a bit more abstracted * which makes this cleaner instead of passing 'sock' everywhere */ struct TIC_conf { SOCKET sock; /* The socket to which we are connected */ }; /********************************************************** TIC Functions **********************************************************/ /* Login to/Logout from the TIC Server */ bool tic_Login(struct TIC_conf *tic, char *username, char *password); void tic_Logout(struct TIC_conf *tic); /* Check if the time is in range */ bool tic_checktime(time_t epochtime); /* Get Tunnel/Route/POP List */ struct TIC_sTunnel *tic_ListTunnels(struct TIC_conf *tic); struct TIC_sRoute *tic_ListRoutes(struct TIC_conf *tic); struct TIC_sPOP *tic_ListPOPs(struct TIC_conf *tic); /* Get Tunnel/Route/POP Information */ struct TIC_Tunnel *tic_GetTunnel(struct TIC_conf *tic, char *sId); struct TIC_Route *tic_GetRoute(struct TIC_conf *tic, char *sId); struct TIC_POP *tic_GetPOP(struct TIC_conf *tic, char *sId); /* Free Information structures */ void tic_Free_sTunnel(struct TIC_sTunnel *tun); void tic_Free_sRoute(struct TIC_sRoute *rt); void tic_Free_sPOP(struct TIC_sPOP *pop); void tic_Free_Tunnel(struct TIC_Tunnel *tun); void tic_Free_Route(struct TIC_Route *rt); void tic_Free_POP(struct TIC_POP *pop); #endif /* TIC_H */ aiccu/common/hash_md5.h0000664000175200017530000000340710115316472012227 00000000000000/* * This is the header file for the MD5 message-digest algorithm. * The algorithm is due to Ron Rivest. This code was * written by Colin Plumb in 1993, no copyright is claimed. * This code is in the public domain; do with it what you wish. * * Equivalent code is available from RSA Data Security, Inc. * This code has been tested against that, and is equivalent, * except that you don't need to include two pages of legalese * with every copy. * * To compute the message digest of a chunk of bytes, declare an * MD5Context structure, pass it to MD5Init, call MD5Update as * needed on buffers full of bytes, and then call MD5Final, which * will fill a supplied 16-byte array with the digest. * * Changed so as no longer to depend on Colin Plumb's `usual.h' * header definitions; now uses stuff from dpkg's config.h * - Ian Jackson . * Still in the public domain. */ #ifndef MD5_H #define MD5_H #include "common.h" #ifdef _WIN32 #ifdef __alpha typedef unsigned int uint32; #else typedef unsigned long uint32; #define UWORD32 uint32 #endif #else #define UWORD32 u_int32_t #endif /* Determine Endianness */ #if BYTE_ORDER == LITTLE_ENDIAN /* 1234 machines */ #elif BYTE_ORDER == BIG_ENDIAN /* 4321 machines */ # define WORDS_BIGENDIAN 1 #elif BYTE_ORDER == PDP_ENDIAN /* 3412 machines */ #error PDP endianness not supported yet! #else #error unknown endianness! #endif #define md5byte unsigned char struct MD5Context { UWORD32 buf[4]; UWORD32 bytes[2]; UWORD32 in[16]; }; void MD5Init(struct MD5Context *context); void MD5Update(struct MD5Context *context, md5byte const *buf, unsigned len); void MD5Final(unsigned char digest[16], struct MD5Context *context); void MD5Transform(UWORD32 buf[4], UWORD32 const in[16]); #endif /* !MD5_H */ aiccu/common/hash_sha1.c0000664000175200017530000001414410120010164012352 00000000000000/* * sha1.c * * Originally witten by Steve Reid * * Modified by Aaron D. Gifford * * NO COPYRIGHT - THIS IS 100% IN THE PUBLIC DOMAIN * * The original unmodified version is available at: * ftp://ftp.funet.fi/pub/crypt/hash/sha/sha1.c * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "hash_sha1.h" #include #include #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) /* blk0() and blk() perform the initial expand. */ /* I got the idea of expanding during the round function from SSLeay */ #if BYTE_ORDER == LITTLE_ENDIAN #define blk0(i) (block->l[i] = (rol(block->l[i],24)&(sha1_quadbyte)0xFF00FF00) \ |(rol(block->l[i],8)&(sha1_quadbyte)0x00FF00FF)) #else #define blk0(i) block->l[i] #endif #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \ ^block->l[(i+2)&15]^block->l[i&15],1)) /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */ #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30); #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30); #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30); #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); typedef union _BYTE64QUAD16 { sha1_byte c[64]; sha1_quadbyte l[16]; } BYTE64QUAD16; /* Hash a single 512-bit block. This is the core of the algorithm. */ void SHA1_Transform(sha1_quadbyte state[5], const sha1_byte buffer[64]) { sha1_quadbyte a, b, c, d, e; BYTE64QUAD16 *block; block = (BYTE64QUAD16*)buffer; /* Copy context->state[] to working vars */ a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4]; /* 4 rounds of 20 operations each. Loop unrolled. */ R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3); R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11); R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15); R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); /* Add the working vars back into context.state[] */ state[0] += a; state[1] += b; state[2] += c; state[3] += d; state[4] += e; /* Wipe variables */ a = b = c = d = e = 0; } /* SHA1_Init - Initialize new context */ void SHA1_Init(SHA_CTX* context) { /* SHA1 initialization constants */ context->state[0] = 0x67452301; context->state[1] = 0xEFCDAB89; context->state[2] = 0x98BADCFE; context->state[3] = 0x10325476; context->state[4] = 0xC3D2E1F0; context->count[0] = context->count[1] = 0; } /* Run your data through this. */ void SHA1_Update(SHA_CTX *context, const sha1_byte *d, unsigned int len) { unsigned int i, j; /* Make a temporary storage as Transform destroys it */ sha1_byte *data = (sha1_byte *)malloc(len); if (!data) exit(-42); memcpy(data, d, len); j = (context->count[0] >> 3) & 63; if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++; context->count[1] += (len >> 29); if ((j + len) > 63) { memcpy(&context->buffer[j], data, (i = 64-j)); SHA1_Transform(context->state, context->buffer); for ( ; i + 63 < len; i += 64) { SHA1_Transform(context->state, &data[i]); } j = 0; } else i = 0; memcpy(&context->buffer[j], &data[i], len - i); /* Free the temporary buffer */ free(data); } /* Add padding and return the message digest. */ void SHA1_Final(sha1_byte digest[SHA1_DIGEST_LENGTH], SHA_CTX *context) { sha1_quadbyte i, j; sha1_byte finalcount[8]; for (i = 0; i < 8; i++) { finalcount[i] = (sha1_byte)((context->count[(i >= 4 ? 0 : 1)] >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */ } SHA1_Update(context, (sha1_byte *)"\200", 1); while ((context->count[0] & 504) != 448) { SHA1_Update(context, (sha1_byte *)"\0", 1); } /* Should cause a SHA1_Transform() */ SHA1_Update(context, finalcount, 8); for (i = 0; i < SHA1_DIGEST_LENGTH; i++) { digest[i] = (sha1_byte) ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255); } /* Wipe variables */ i = j = 0; memset(context->buffer, 0, SHA1_BLOCK_LENGTH); memset(context->state, 0, SHA1_DIGEST_LENGTH); memset(context->count, 0, 8); memset(&finalcount, 0, 8); } aiccu/common/hash_sha1.h0000664000175200017530000000447010115316472012377 00000000000000/* * sha.h * * Originally taken from the public domain SHA1 implementation * written by by Steve Reid * * Modified by Aaron D. Gifford * * NO COPYRIGHT - THIS IS 100% IN THE PUBLIC DOMAIN * * The original unmodified version is available at: * ftp://ftp.funet.fi/pub/crypt/hash/sha/sha1.c * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR(S) OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef __SHA1_H__ #define __SHA1_H__ #ifdef __cplusplus extern "C" { #endif #include "common.h" /* Define this if your machine is LITTLE_ENDIAN, otherwise #undef it: */ /* Is defined in endian.h */ /* #define LITTLE_ENDIAN */ /* Make sure you define these types for your architecture: */ typedef u_int32_t sha1_quadbyte; /* 4 byte type */ typedef u_int8_t sha1_byte; /* single byte type */ /* * Be sure to get the above definitions right. For instance, on my * x86 based FreeBSD box, I define LITTLE_ENDIAN and use the type * "unsigned long" for the quadbyte. On FreeBSD on the Alpha, however, * while I still use LITTLE_ENDIAN, I must define the quadbyte type * as "unsigned int" instead. */ #define SHA1_BLOCK_LENGTH 64 #define SHA1_DIGEST_LENGTH 20 /* The SHA1 structure: */ typedef struct _SHA_CTX { sha1_quadbyte state[5]; sha1_quadbyte count[2]; sha1_byte buffer[SHA1_BLOCK_LENGTH]; } SHA_CTX; #ifndef NOPROTO void SHA1_Init(SHA_CTX *context); void SHA1_Update(SHA_CTX *context, const sha1_byte *data, unsigned int len); void SHA1_Final(sha1_byte digest[SHA1_DIGEST_LENGTH], SHA_CTX* context); #else void SHA1_Init(); void SHA1_Update(); void SHA1_Final(); #endif #ifdef __cplusplus } #endif #endif aiccu/common/hash_md5.c0000664000175200017530000001647510115316472012233 00000000000000/* * This code implements the MD5 message-digest algorithm. * The algorithm is due to Ron Rivest. This code was * written by Colin Plumb in 1993, no copyright is claimed. * This code is in the public domain; do with it what you wish. * * Equivalent code is available from RSA Data Security, Inc. * This code has been tested against that, and is equivalent, * except that you don't need to include two pages of legalese * with every copy. * * To compute the message digest of a chunk of bytes, declare an * MD5Context structure, pass it to MD5Init, call MD5Update as * needed on buffers full of bytes, and then call MD5Final, which * will fill a supplied 16-byte array with the digest. * * Changed so as no longer to depend on Colin Plumb's `usual.h' header * definitions; now uses stuff from dpkg's config.h. * - Ian Jackson . * Still in the public domain. */ #include "aiccu.h" #include "hash_md5.h" #include /* for memcpy() */ #include /* for stupid systems */ #ifdef WORDS_BIGENDIAN void byteSwap(UWORD32 *buf, unsigned words) { md5byte *p = (md5byte *)buf; do { *buf++ = (UWORD32)((unsigned)p[3] << 8 | p[2]) << 16 | ((unsigned)p[1] << 8 | p[0]); p += 4; } while (--words); } #else #define byteSwap(buf,words) #endif /* * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious * initialization constants. */ void MD5Init(struct MD5Context *ctx) { ctx->buf[0] = 0x67452301; ctx->buf[1] = 0xefcdab89; ctx->buf[2] = 0x98badcfe; ctx->buf[3] = 0x10325476; ctx->bytes[0] = 0; ctx->bytes[1] = 0; } /* * Update context to reflect the concatenation of another buffer full * of bytes. */ void MD5Update(struct MD5Context *ctx, md5byte const *buf, unsigned len) { UWORD32 t; /* Update byte count */ t = ctx->bytes[0]; if ((ctx->bytes[0] = t + len) < t) ctx->bytes[1]++; /* Carry from low to high */ t = 64 - (t & 0x3f); /* Space available in ctx->in (at least 1) */ if (t > len) { memcpy((md5byte *)ctx->in + 64 - t, buf, len); return; } /* First chunk is an odd size */ memcpy((md5byte *)ctx->in + 64 - t, buf, t); byteSwap(ctx->in, 16); MD5Transform(ctx->buf, ctx->in); buf += t; len -= t; /* Process data in 64-byte chunks */ while (len >= 64) { memcpy(ctx->in, buf, 64); byteSwap(ctx->in, 16); MD5Transform(ctx->buf, ctx->in); buf += 64; len -= 64; } /* Handle any remaining bytes of data. */ memcpy(ctx->in, buf, len); } /* * Final wrapup - pad to 64-byte boundary with the bit pattern * 1 0* (64-bit count of bits processed, MSB-first) */ void MD5Final(md5byte digest[16], struct MD5Context *ctx) { int count = ctx->bytes[0] & 0x3f; /* Number of bytes in ctx->in */ md5byte *p = (md5byte *)ctx->in + count; /* Set the first char of padding to 0x80. There is always room. */ *p++ = 0x80; /* Bytes of padding needed to make 56 bytes (-8..55) */ count = 56 - 1 - count; if (count < 0) { /* Padding forces an extra block */ memset(p, 0, count + 8); byteSwap(ctx->in, 16); MD5Transform(ctx->buf, ctx->in); p = (md5byte *)ctx->in; count = 56; } memset(p, 0, count); byteSwap(ctx->in, 14); /* Append length in bits and transform */ ctx->in[14] = ctx->bytes[0] << 3; ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29; MD5Transform(ctx->buf, ctx->in); byteSwap(ctx->buf, 4); memcpy(digest, ctx->buf, 16); memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */ } #ifndef ASM_MD5 /* The four core functions - F1 is optimized somewhat */ /* #define F1(x, y, z) (x & y | ~x & z) */ #define F1(x, y, z) (z ^ (x & (y ^ z))) #define F2(x, y, z) F1(z, x, y) #define F3(x, y, z) (x ^ y ^ z) #define F4(x, y, z) (y ^ (x | ~z)) /* This is the central step in the MD5 algorithm. */ #define MD5STEP(f,w,x,y,z,in,s) \ (w += f(x,y,z) + in, w = (w<>(32-s)) + x) /* * The core of the MD5 algorithm, this alters an existing MD5 hash to * reflect the addition of 16 longwords of new data. MD5Update blocks * the data and converts bytes into longwords for this routine. */ void MD5Transform(UWORD32 buf[4], UWORD32 const in[16]) { register UWORD32 a, b, c, d; a = buf[0]; b = buf[1]; c = buf[2]; d = buf[3]; MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); buf[0] += a; buf[1] += b; buf[2] += c; buf[3] += d; } #endif aiccu/common/aiccu_freebsd4.c0000775000175200017530000000311610120011666013365 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu_freebsd4.c - FreeBSD 3.x/4.x *********************************************************** $Author: jeroen $ $Id: aiccu_freebsd4.c,v 1.4 2004/09/09 08:26:30 jeroen Exp $ $Date: 2004/09/09 08:26:30 $ **********************************************************/ #include "aiccu.h" void aiccu_os_install() { } void aiccu_os_setup(struct TIC_Tunnel *hTunnel) { if (strcmp(hTunnel->sType, "ayiya") != 0) { aiccu_exec( "/sbin/ifconfig %s create", g_aiccu->ipv6_interface); aiccu_exec( "/sbin/ifconfig %s tunnel %s %s", g_aiccu->ipv6_interface, strcmp(hTunnel->sIPv4_Local, "heartbeat") == 0 ? "0.0.0.0" : hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } aiccu_exec( "ifconfig %s up", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s inet6 %s prefixlen 128 alias", g_aiccu->ipv6_interface, hTunnel->sIPv6_Local); aiccu_exec( "route add -inet6 %s %s", "default", hTunnel->sIPv6_POP); } void aiccu_os_reconfig(struct TIC_Tunnel *hTunnel) { aiccu_exec( "/sbin/ifconfig %s tunnel %s %s", g_aiccu->ipv6_interface, hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } void aiccu_os_delete(struct TIC_Tunnel *hTunnel) { hTunnel = hTunnel; aiccu_exec( "ifconfig %s down", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s destroy", g_aiccu->ipv6_interface); } aiccu/common/aiccu_linux.c0000775000175200017530000000365610115321377013046 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu_linux.c - AICCU Linux Abstracted functions *********************************************************** $Author: jeroen $ $Id: aiccu_linux.c,v 1.4 2004/09/01 10:22:55 jeroen Exp $ $Date: 2004/09/01 10:22:55 $ **********************************************************/ #include "aiccu.h" void aiccu_os_install() { /* Just try to load it, doesn't really matter if it fails */ system("modprobe -q ipv6 2>/dev/null >/dev/null"); } void aiccu_os_setup(struct TIC_Tunnel *hTunnel) { if (strcmp(hTunnel->sType, "ayiya") != 0) { aiccu_exec( "ip tunnel add %s mode sit %s%s remote %s", g_aiccu->ipv6_interface, strcmp(hTunnel->sIPv4_Local, "heartbeat") == 0 ? "" : "local ", strcmp(hTunnel->sIPv4_Local, "heartbeat") == 0 ? "" : hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } aiccu_exec( "ip link set %s up", g_aiccu->ipv6_interface); aiccu_exec( "ip link set mtu 1280 dev %s", g_aiccu->ipv6_interface); if (strcmp(hTunnel->sType, "ayiya") != 0) { aiccu_exec( "ip tunnel change %s ttl 64", g_aiccu->ipv6_interface); } aiccu_exec( "ip -6 addr add %s/%u dev %s", hTunnel->sIPv6_Local, hTunnel->nIPv6_PrefixLength, g_aiccu->ipv6_interface); aiccu_exec( "ip -6 ro add %s via %s dev %s", "default", hTunnel->sIPv6_POP, g_aiccu->ipv6_interface); } void aiccu_os_reconfig(struct TIC_Tunnel *hTunnel) { aiccu_exec( "ip tunnel change %s local %s", g_aiccu->ipv6_interface, hTunnel->sIPv4_Local); } void aiccu_os_delete(struct TIC_Tunnel *hTunnel) { hTunnel = hTunnel; aiccu_exec( "ip link set %s down", g_aiccu->ipv6_interface); aiccu_exec( "ip tunnel del %s", g_aiccu->ipv6_interface); } aiccu/common/ayiya.h0000775000175200017530000000534310120011666011650 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/ayiya.c - AYIYA - Anything In Anything *********************************************************** $Author: jeroen $ $Id: ayiya.h,v 1.4 2004/09/09 08:26:30 jeroen Exp $ $Date: 2004/09/09 08:26:30 $ **********************************************************/ #ifndef AYIYA_H #define AYIYA_H "H5K7:W3NDY5UU5N1K1N1C0l3" #include "common.h" #include "tic.h" /* Anything In Anything - AYIYA (uses UDP in our case) */ /* The port number spells BETA as there is no IANA assigned port. */ #define AYIYA_PORT "8374" /* * AYIYA version (which document this should conform to) * Per draft-massar-v6ops-ayiya-02 (July 2004) */ #define AYIYA_VERSION "draft-02" enum ayiya_identities { ayiya_id_none = 0x0, /* None */ ayiya_id_integer = 0x1, /* Integer */ ayiya_id_string = 0x2 /* ASCII String */ }; enum ayiya_hash { ayiya_hash_none = 0x0, /* No hash */ ayiya_hash_md5 = 0x1, /* MD5 Signature */ ayiya_hash_sha1 = 0x2 /* SHA1 Signature */ }; enum ayiya_auth { ayiya_auth_none = 0x0, /* No authentication */ ayiya_auth_sharedsecret = 0x1, /* Shared Secret */ ayiya_auth_pgp = 0x2 /* Public/Private Key */ }; enum ayiya_opcode { ayiya_op_noop = 0x0, /* No Operation */ ayiya_op_forward = 0x1, /* Forward */ ayiya_op_echo_request = 0x2, /* Echo Request */ ayiya_op_echo_request_forward = 0x3, /* Echo Request and Forward */ ayiya_op_echo_response = 0x4, /* Echo Response */ ayiya_op_motd = 0x5, /* MOTD */ ayiya_op_query_request = 0x6, /* Query Request */ ayiya_op_query_response = 0x7 /* Query Response */ }; struct ayiyahdr { #if BYTE_ORDER == BIG_ENDIAN u_int32_t ayh_idlen: 4; /* Identity Length */ u_int32_t ayh_idtype: 4; /* Identity Type */ u_int32_t ayh_siglen: 4; /* Signature Length */ u_int32_t ayh_hshmeth:4; /* Hashing Method */ u_int32_t ayh_autmeth:4; /* Authentication Method */ u_int32_t ayh_opcode: 4; /* Operation Code */ #elif BYTE_ORDER == LITTLE_ENDIAN u_int32_t ayh_idtype: 4; /* Identity Type */ u_int32_t ayh_idlen: 4; /* Identity Length */ u_int32_t ayh_hshmeth:4; /* Hashing Method */ u_int32_t ayh_siglen: 4; /* Signature Length */ u_int32_t ayh_opcode: 4; /* Operation Code */ u_int32_t ayh_autmeth:4; /* Authentication Method */ #else #error unsupported endianness! #endif u_int8_t ayh_nextheader; /* Next Header (PROTO_*) */ u_int32_t ayh_epochtime; /* Time in seconds since "00:00:00 1970-01-01 UTC" */ }; /* Functions */ bool ayiya(struct TIC_Tunnel *hTunnel); #endif /* AYIYA_H */ aiccu/common/aiccu_test.c0000775000175200017530000001377010115321377012664 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu_test.c - AICCU Test function *********************************************************** $Author: jeroen $ $Id: aiccu_test.c,v 1.2 2004/09/01 10:22:55 jeroen Exp $ $Date: 2004/09/01 10:22:55 $ **********************************************************/ #include "aiccu.h" #ifndef _WIN32 #define PING4 "ping -c %d -v %s 2>&1" #define PING6 "ping6 -c %d -v %s 2>&1" #define TRACEROUTE4 "traceroute %s 2>&1" #define TRACEROUTE6 "traceroute6 %s 2>&1" #else #define PING4 "ping -4 -n %d %s" #define PING6 "ping -6 -n %d %s" #define TRACEROUTE4 "tracert %s" #define TRACEROUTE6 "tracert6 %s" #endif void system_arg(char *fmt, ...) { char buf[1024]; va_list ap; va_start(ap, fmt); vsnprintf(buf, sizeof(buf), fmt, ap); va_end(ap); fflush(stdout); system(buf); } #define PINGCOUNT 3 #define TOTTESTS 8 bool test_ask(bool automatic) { char buf[100]; printf("\n######\n"); printf("\n"); if (automatic) return true; printf("Did this work? [Y/n] "); fgets(buf, sizeof(buf), stdin); printf("\n"); return (buf[0] == 'N' || buf[0] == 'n' ? false : true); } void aiccu_os_test(struct TIC_Tunnel *hTunnel, bool automatic) { unsigned int t = 1; /* Make sure we have a correct local IPv4 address for heartbeats */ if (strcmp(hTunnel->sType, "6in4-heartbeat") == 0) { heartbeat_socket(NULL, 0, "", &hTunnel->sIPv4_Local, hTunnel->sIPv4_POP, NULL); } printf("#######\n"); printf("####### AICCU Quick Connectivity Test\n"); printf("#######\n\n"); printf("####### [%u/%u] Ping the IPv4 Local/Your Outer Endpoint (%s)\n", t++, TOTTESTS, hTunnel->sIPv4_Local); printf("### This should return so called 'echo replies'\n"); printf("### If it doesn't then check your firewall settings\n"); printf("### Your local endpoint should always be pingable\n"); printf("### It could also indicate problems with your IPv4 stack\n"); printf("\n"); system_arg(PING4, PINGCOUNT, hTunnel->sIPv4_Local); if (!test_ask(automatic)) return; printf("####### [%u/%u] Ping the IPv4 Remote/POP Outer Endpoint (%s)\n", t++, TOTTESTS, hTunnel->sIPv4_POP); printf("### These pings should reach the POP and come back to you\n"); printf("### In case there are problems along the route between your\n"); printf("### host and the POP this could not return replies\n"); printf("### Check your firewall settings if problems occur\n"); printf("\n"); system_arg(PING4, PINGCOUNT, hTunnel->sIPv4_POP); if (!test_ask(automatic)) return; printf("####### [%u/%u] Traceroute to the POP (%s) over IPv4\n", t++, TOTTESTS, hTunnel->sIPv4_POP); printf("### This traceroute should reach the POP\n"); printf("### In case this traceroute fails then you have no connectivity\n"); printf("### to the POP and this is most probably the problem\n"); printf("\n"); system_arg(TRACEROUTE4, hTunnel->sIPv4_POP); if (!test_ask(automatic)) return; printf("###### [%u/%u] Checking if we can ping IPv6 localhost (::1)\n", t++, TOTTESTS); printf("### This confirms if your IPv6 is working\n"); printf("### If ::1 doesn't reply then something is wrong with your IPv6 stack\n"); printf("\n"); system_arg(PING6, PINGCOUNT, "::1"); if (!test_ask(automatic)) return; printf("###### [%u/%u] Ping the IPv6 Local/Your Inner Tunnel Endpoint (%s)\n", t++, TOTTESTS, hTunnel->sIPv6_Local); printf("### This confirms that your tunnel is configured\n"); printf("### If it doesn't reply then check your interface and routing tables\n"); printf("\n"); system_arg(PING6, PINGCOUNT, hTunnel->sIPv6_Local); if (!test_ask(automatic)) return; printf("###### [%u/%u] Ping the IPv6 Remote/POP Inner Tunnel Endpoint (%s)\n", t++, TOTTESTS, hTunnel->sIPv6_POP); printf("### This confirms the reachability of the other side of the tunnel\n"); printf("### If it doesn't reply then check your interface and routing tables\n"); printf("### Don't forget to check your firewall of course\n"); printf("### If the previous test was succesful then this could be both\n"); printf("### a firealling and a routing/interface problem\n"); printf("\n"); system_arg(PING6, PINGCOUNT, hTunnel->sIPv6_POP); if (!test_ask(automatic)) return; printf("###### [%u/%u] Traceroute6 to the central SixXS machine (noc.sixxs.net)\n", t++, TOTTESTS); printf("### This confirms that you can reach the central machine of SixXS\n"); printf("### If that one is reachable you should be able to reach most IPv6 destinations\n"); printf("### Also check http://www.sixxs.net/ipv6calc/ which should show an IPv6 connection\n"); printf("### If your browser supports IPv6 and uses it of course.\n"); printf("\n"); system_arg(TRACEROUTE6, "noc.sixxs.net"); if (!test_ask(automatic)) return; printf("###### [%u/%u] Traceroute6 to (www.kame.net)\n", t++, TOTTESTS); printf("### This confirms that you can reach a Japanese IPv6 destination\n"); printf("### If that one is reachable you should be able to reach most IPv6 destinations\n"); printf("### You should also check http://www.kame.net which should display\n"); printf("### a animated kame (turtle), of course only when your browser supports and uses IPv6\n"); printf("\n"); system_arg(TRACEROUTE6, "www.kame.net"); if (!test_ask(automatic)) return; printf("###### ACCU Quick Connectivity Test (done)\n\n"); printf("### Either the above all works and gives no problems\n"); printf("### or it shows you where what goes wrong\n"); printf("### Check the SixXS FAQ (http://www.sixxs.net/faq/\n"); printf("### for more information and possible solutions or hints\n"); printf("### Don't forget to check the Forums (http://www.sixxs.net/forum/)\n"); printf("### for a helping hand.\n"); printf("### Passing the output of 'aiccu autotest >aiccu.log' is a good idea.\n"); if (!automatic) { /* Wait for a keypress */ printf("\n\n*** press a key to continue ***\n"); getchar(); } } aiccu/common/aiccu_kame.c0000775000175200017530000000312110120011666012600 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu_kame.c - NetBSD + FreeBSD 5.x+ *********************************************************** $Author: jeroen $ $Id: aiccu_kame.c,v 1.4 2004/09/09 08:26:30 jeroen Exp $ $Date: 2004/09/09 08:26:30 $ **********************************************************/ #include "aiccu.h" void aiccu_os_install() { } void aiccu_os_setup(struct TIC_Tunnel *hTunnel) { if (strcmp(hTunnel->sType, "ayiya") != 0) { aiccu_exec( "/sbin/ifconfig %s create", g_aiccu->ipv6_interface); aiccu_exec( "/sbin/ifconfig %s tunnel %s %s", g_aiccu->ipv6_interface, strcmp(hTunnel->sIPv4_Local, "heartbeat") == 0 ? "0.0.0.0" : hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } aiccu_exec( "ifconfig %s up", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s inet6 %s prefixlen 128 alias", g_aiccu->ipv6_interface, hTunnel->sIPv6_Local); aiccu_exec( "route add -inet6 %s %s", "default", hTunnel->sIPv6_POP); } void aiccu_os_reconfig(struct TIC_Tunnel *hTunnel) { aiccu_exec( "/sbin/ifconfig %s tunnel %s %s", g_aiccu->ipv6_interface, hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } void aiccu_os_delete(struct TIC_Tunnel *hTunnel) { hTunnel = hTunnel; aiccu_exec( "ifconfig %s down", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s deletetunnel", g_aiccu->ipv6_interface); } aiccu/common/aiccu_darwin.c0000775000175200017530000000301610132757561013170 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu_darwin.c - Darwin *********************************************************** $Author: jeroen $ $Id: aiccu_darwin.c,v 1.1 2004/10/12 13:43:13 jeroen Exp $ $Date: 2004/10/12 13:43:13 $ **********************************************************/ #include "aiccu.h" void aiccu_os_install() { } void aiccu_os_setup(struct TIC_Tunnel *hTunnel) { if (strcmp(hTunnel->sType, "ayiya") != 0) { aiccu_exec( "/sbin/ifconfig %s tunnel %s %s", g_aiccu->ipv6_interface, strcmp(hTunnel->sIPv4_Local, "heartbeat") == 0 ? "0.0.0.0" : hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } aiccu_exec( "ifconfig %s up", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s inet6 %s prefixlen %u alias", g_aiccu->ipv6_interface hTunnel->sIPv6_Local, hTunnel->nIPv6_PrefixLength); aiccu_exec( "route add -inet6 default %s", hTunnel->sIPv6_POP); } void aiccu_os_reconfig(struct TIC_Tunnel *hTunnel) { aiccu_exec( "/sbin/ifconfig %s tunnel %s %s", g_aiccu->ipv6_interface, hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } void aiccu_os_delete(struct TIC_Tunnel *hTunnel) { hTunnel = hTunnel; aiccu_exec( "ifconfig %s down", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s deletetunnel", g_aiccu->ipv6_interface); } aiccu/common/aiccu_openbsd2.c0000664000175200017530000000321110140406767013410 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** common/aiccu_openbsd2.c - OpenBSD 2.7-2.9 *********************************************************** $Author: jeroen $ $Id: aiccu_openbsd2.c,v 1.1 2004/10/29 09:31:35 jeroen Exp $ $Date: 2004/10/29 09:31:35 $ Provided by Wouter Van Hemel **********************************************************/ #include "aiccu.h" void aiccu_os_install() { } void aiccu_os_setup(struct TIC_Tunnel *hTunnel) { if (strcmp(hTunnel->sType, "ayiya") != 0) { aiccu_exec( "/sbin/ifconfig %s giftunnel %s %s", g_aiccu->ipv6_interface, strcmp(hTunnel->sIPv4_Local, "heartbeat") == 0 ? "0.0.0.0" : hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } aiccu_exec( "ifconfig %s up", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s inet6 %s %s prefixlen 128 alias", g_aiccu->ipv6_interface, hTunnel->sIPv6_Local, hTunnel->sIPv6_POP); aiccu_exec( "route add -inet6 %s %s", "default", hTunnel->sIPv6_POP); } void aiccu_os_reconfig(struct TIC_Tunnel *hTunnel) { aiccu_exec( "/sbin/ifconfig %s giftunnel %s %s", g_aiccu->ipv6_interface, hTunnel->sIPv4_Local, hTunnel->sIPv4_POP); } void aiccu_os_delete(struct TIC_Tunnel *hTunnel) { hTunnel = hTunnel; aiccu_exec( "ifconfig %s down", g_aiccu->ipv6_interface); aiccu_exec( "ifconfig %s inet6 %s %s prefixlen 128 -alias", g_aiccu->ipv6_interface, hTunnel->sIPv6_Local, hTunnel->sIPv6_POP); } aiccu/debian/0000775000175200017530000000000010142110717010366 500000000000000aiccu/debian/control0000664000175200017530000000113110121761131011704 00000000000000Source: aiccu Section: net Priority: optional Maintainer: SixXS Staff Build-Depends: debhelper (>> 3.0.0) Standards-Version: 3.5.2 Package: aiccu Architecture: any Depends: ${shlibs:Depends}, iputils-ping, iputils-tracepath, iproute Description: SixXS Automatic IPv6 Connectivity Client Utility This client automatically gives one IPv6 connectivity without having to manually configure interfaces etc. One does need a SixXS account and at least a tunnel. These can be freely & gratis requested from the SixXS website. For more information about SixXS check http://www.sixxs.net aiccu/debian/rules0000775000175200017530000000315110122511774011374 00000000000000#!/usr/bin/make -f # Sample debian/rules that uses debhelper. # GNU copyright 1997 to 1999 by Joey Hess. # Adjusted by Jeroen Massar for aiccu # Uncomment this to turn on verbose mode. #export DH_VERBOSE=1 # This is the debhelper compatability version to use. export DH_COMPAT=3 configure: configure-stamp configure-stamp: dh_testdir touch configure-stamp build: build-stamp build-stamp: configure-stamp dh_testdir # Add here commands to compile the package. $(MAKE) touch build-stamp clean: dh_testdir rm -f build-stamp configure-stamp # Add here commands to clean up after the build process. -$(MAKE) clean dh_clean install: build dh_testdir dh_testroot dh_clean -k dh_installdirs # Add here commands to install the package into debian/aiccu $(MAKE) DESTDIR=`pwd`/debian/aiccu install # Install the default configuration file cp doc/aiccu.conf `pwd`/debian/aiccu/etc/aiccu.conf # Build architecture-independent files here. binary-indep: build install # We have nothing to do by default. # Build architecture-dependent files here. binary-arch: build install dh_testdir dh_testroot # dh_installdebconf dh_installdocs dh_installexamples dh_installmenu # dh_installlogrotate # dh_installemacsen # dh_installpam # dh_installmime dh_installinit dh_installcron dh_installman dh_installinfo # dh_undocumented dh_installchangelogs dh_link dh_strip dh_compress dh_fixperms # dh_makeshlibs dh_installdeb # dh_perl dh_shlibdeps dh_gencontrol dh_md5sums dh_builddeb binary: binary-indep binary-arch .PHONY: build clean binary-indep binary-arch binary install configure aiccu/debian/dirs0000664000175200017530000000001110112113442011155 00000000000000usr/sbin aiccu/debian/docs0000664000175200017530000000004110114427524011162 00000000000000doc/README doc/LICENSE doc/HOWTO aiccu/debian/changelog0000644000175200017530000000354310142110710012154 00000000000000aiccu (2004-11-03-beta2c) stable; urgency=low * MacOS X support (Marc Kramis) * DEBUG messages are not logged anymore * OpenBSD 2.x/3.x support (Wouter van Hemel) * Don't overwrite config when doing a 'make install' (Wouter van Hemel) * Manual page (Antonio Ospite) * Windows Configuration directory based on GetWindowsDirectory() (Thomas B. Ruecker) * Windows NAT message fix (Thomas B. Ruecker) -- Jeroen Massar Wed, 3 Nov 2004 09:00:42 +0100 aiccu (2004-09-17-beta2b) stable; urgency=low * OpenBSD fixes (AO) * debian/rules debclean - now calls the correct clean (A0) * Debian dependency on iproute (MdI) * Gentoo Port (Thorsten Becker) -- Jeroen Massar Sun, 12 Sep 2004 10:24:42 +0100 aiccu (2004-09-09-beta2a) stable; urgency=low * Compile with pendantic, removing C++ "//" comments (AO) * Debian fixes: file permissions, distclean (AO) * rc.d addon (AO) * Remove superfluous CVS dirs (AO) * init script fix specifying 'start' (RS) * RPM_OPT_FLAGS passing (RS) * License fixes, making it more open (PvD & MdI) * RPM package (RS) * FreeBSD 4.x + 5.x port (MA) * Many more fixes and cleanups (JM) Who/what: * AO = Antonio Ospite * RS = Robert Schiele * PvD = Peter van Dijk * MdI = Marco d'Itri * MA = Meno Abels * JM = Jeroen Massar -- Jeroen Massar Thu, 09 Sep 2004 10:24:42 +0100 aiccu (2004-08-30-beta2) stable; urgency=low * Updated LICENSE which should now be 100% free(tm) * Local-IP fix when using heartbeat tunnels -- Jeroen Massar Mon, 30 Aug 2004 21:26:42 +0100 aiccu (2004-08-29-beta2) stable; urgency=low * Brand spanking new AICCU * Compiles both on Windows and UNIX * Supports: - TIC - 6in4-static - 6in4-heartbeat - AYIYA -- Jeroen Massar Sun, 29 Aug 2004 20:55:42 +0100 aiccu/debian/aiccu.init0000755000175200017530000000251010122515127012260 00000000000000#! /bin/sh # # /etc/init.d/aiccu: start / stop AICCU # # Jeroen Massar PATH=/sbin:/bin:/usr/sbin:/usr/bin NAME=aiccu DAEMON=/usr/sbin/${NAME} DESC="SixXS Automatic IPv6 Connectivity Client Utility (${NAME})" BACKGROUND=true # Options OPTIONS="" test -x $DAEMON || exit 0 # Verify that the configuration file exists if [ ! -f /etc/aiccu.conf ]; then echo "AICCU Configuration file /etc/aiccu.conf doesn't exist" exit 0; fi # Verify that the configuration is correct if [ `grep -c "^username" /etc/aiccu.conf 2>/dev/null` -ne 1 ]; then echo "AICCU is not configured, edit /etc/aiccu.conf first" exit 0; fi if [ -f /etc/default/${NAME} ]; then . /etc/default/${NAME} fi if [ "$BACKGROUND" = "false" ]; then exit 0; fi case "$1" in start) echo -n "Starting $DESC: " start-stop-daemon --start --oknodo --quiet --exec $DAEMON -- start $OPTIONS echo "$NAME." ;; stop) echo -n "Stopping $DESC: " start-stop-daemon --stop --oknodo --quiet --exec $DAEMON -- stop echo "$NAME." ;; restart|reload|force-reload) echo -n "Restarting $DESC: " start-stop-daemon --stop --oknodo --quiet --exec $DAEMON -- stop sleep 2 start-stop-daemon --start --oknodo --quiet --exec $DAEMON -- start $OPTIONS echo "$NAME." ;; *) echo "Usage: /etc/init.d/$NAME {start|stop|reload|force-reload|restart}" >&2 exit 1 esac exit 0 aiccu/doc/0000775000175200017530000000000010142105566007717 500000000000000aiccu/doc/changelog0000644000175200017530000000331310132757066011516 00000000000000aiccu (2004-10-12-beta2c) stable; urgency=low * Added Darwin (Mac OS X) support Requires: http://chrisp.de/en/projects/tunnel.html With thanks to Marc Kramis, AICCU was succesfully tested on a setup from behind a NAT/Firewall combo (Cisco PIX) -- Jeroen Massar Sun, 12 Oct 2004 15:36:42 +0100 aiccu (2004-09-17-beta2b) stable; urgency=low * OpenBSD fixes (AO) * debian/rules debclean - now calls the correct clean (A0) * Debian dependency on iproute (MdI) * Gentoo Port (Thorsten Becker) -- Jeroen Massar Sun, 17 Sep 2004 10:24:42 +0100 aiccu (2004-09-09-beta2a) stable; urgency=low * Compile with pendantic, removing C++ "//" comments (AO) * Debian fixes: file permissions, distclean (AO) * rc.d addon (AO) * Remove superfluous CVS dirs (AO) * init script fix specifying 'start' (RS) * RPM_OPT_FLAGS passing (RS) * License fixes, making it more open (PvD & MdI) * RPM package (RS) * FreeBSD 4.x + 5.x port (MA) * Many more fixes and cleanups (JM) Who/what: * AO = Antonio Ospite * RS = Robert Schiele * PvD = Peter van Dijk * MdI = Marco d'Itri * MA = Meno Abels * JM = Jeroen Massar -- Jeroen Massar Thu, 09 Sep 2004 10:24:42 +0100 aiccu (2004-08-30-beta2) stable; urgency=low * Updated LICENSE which should now be 100% free(tm) * Local-IP fix when using heartbeat tunnels -- Jeroen Massar Mon, 30 Aug 2004 21:26:42 +0100 aiccu (2004-08-29-beta2) stable; urgency=low * Brand spanking new AICCU * Compiles both on Windows and UNIX * Supports: - TIC - 6in4-static - 6in4-heartbeat - AYIYA -- Jeroen Massar Sun, 29 Aug 2004 20:55:42 +0100 aiccu/doc/aiccu.init0000755000175200017530000000251010115320147011601 00000000000000#! /bin/sh # # /etc/init.d/aiccu: start / stop AICCU # # Jeroen Massar PATH=/sbin:/bin:/usr/sbin:/usr/bin NAME=aiccu DAEMON=/usr/sbin/${NAME} DESC="SixXS Automatic IPv6 Connectivity Client Utility (${NAME})" BACKGROUND=true # Options OPTIONS="" test -x $DAEMON || exit 0 # Verify that the configuration file exists if [ ! -f /etc/aiccu.conf ]; then echo "AICCU Configuration file /etc/aiccu.conf doesn't exist" exit 0; fi # Verify that the configuration is correct if [ `grep -c "^username" /etc/aiccu.conf 2>/dev/null` -ne 1 ]; then echo "AICCU is not configured, edit /etc/aiccu.conf first" exit 0; fi if [ -f /etc/default/${NAME} ]; then . /etc/default/${NAME} fi if [ "$BACKGROUND" = "false" ]; then exit 0; fi case "$1" in start) echo -n "Starting $DESC: " start-stop-daemon --start --oknodo --quiet --exec $DAEMON -- start $OPTIONS echo "$NAME." ;; stop) echo -n "Stopping $DESC: " start-stop-daemon --stop --oknodo --quiet --exec $DAEMON -- stop echo "$NAME." ;; restart|reload|force-reload) echo -n "Restarting $DESC: " start-stop-daemon --stop --oknodo --quiet --exec $DAEMON -- stop sleep 2 start-stop-daemon --start --oknodo --quiet --exec $DAEMON -- start $OPTIONS echo "$NAME." ;; *) echo "Usage: /etc/init.d/$NAME {start|stop|reload|force-reload|restart}" >&2 exit 1 esac exit 0 aiccu/doc/aiccu.init.rpm0000755000175200017530000000304410115320165012401 00000000000000#!/bin/sh # # description: Starts and stops the AICCU daemon # # pidfile: /var/run/aiccu.pid # config: /etc/aiccu.conf # Source function library. if [ -f /etc/init.d/functions ] ; then . /etc/init.d/functions elif [ -f /etc/rc.d/init.d/functions ] ; then . /etc/rc.d/init.d/functions else exit 0 fi # Avoid using root's TMPDIR unset TMPDIR # Source networking configuration. . /etc/sysconfig/network # Default options OPTIONS= if [ -f /etc/sysconfig/aiccu ]; then . /etc/sysconfig/aiccu fi # Check that networking is up. [ ${NETWORKING} = "no" ] && exit 0 # Check that aiccu.conf exists. [ -f /etc/aiccu.conf ] || exit 0 # Verify that the configuration is correct if [ `grep -c "^username" /etc/aiccu.conf 2>/dev/null` -ne 1 ]; then echo "AICCU is not configured, edit /etc/aiccu.conf first" exit 0; fi RETVAL=0 KIND="AICCU (Automatic IPv6 Connectivity Configuration Utility)" start() { echo -n $"Starting $KIND services: " daemon aiccu start $OPTIONS RETVAL=$? echo [ $RETVAL -eq 0 ] && touch /var/lock/subsys/aiccu || \ RETVAL=1 return $RETVAL } stop() { echo -n $"Shutting down $KIND services: " killproc aiccu RETVAL=$? echo [ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/aiccu echo "" return $RETVAL } restart() { stop start } rhstatus() { status aiccu } case "$1" in start) start ;; stop) stop ;; restart) restart ;; status) rhstatus ;; condrestart) [ -f /var/lock/subsys/aiccu ] && restart || : ;; *) echo $"Usage: $0 {start|stop|restart|status|condrestart}" exit 1 esac exit $? aiccu/doc/HOWTO0000644000175200017530000000115110114404466010456 00000000000000Howto AICCU ~~~~~~~~~~~ - Windows GUI client: - Just run and follow the dialogs. - Window GUI client as a service: - Edit aiccu.conf and fill in the required values. - Install it as a service using "aiccu /i" - "net start aiccu" One can uninstall the service with "aiccu /u" - Unix/Windows console client: - Edit aiccu.conf and fill in the required values. - Just run it. If there any problems: - read the SixXS FAQ at http://www.sixxs.net/faq/ - check the SixXS Forum at http://www.sixxs.net/forum/ If then it still fails, contact the SixXS staff as described per http://www.sixxs.net/contact/ aiccu/doc/LICENSE0000644000175200017530000000474510114676233010657 00000000000000AICCU LICENSE ~~~~~~~~~~~~~ For the quick reader this is a slightly modified BSD license: - names changed from Regents/University to SixXS. - point 3 -'written', for us an email will suffice. - point 4 and 5 added. Basically we thus allow anybody to use it in any way, but we would like to be notified when you are using it for not connecting to SixXS. -- Copyright (C) SixXS All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of SixXS nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior permission. 4. One should not remove any reference to, or logo of, SixXS. 5. When the software is altered to not use SixXS services, one is kindly asked to notify SixXS of this by sending an email to the SixXS Staff at info@sixxs.net, containing at least the following details: 8<-------- Organisation : Organisation Name Email : mailbox@example.com Website : http://www.example.com is using software for: < description of: the usage the reason why it was modified > -------->8 Additional information details may of course be provided. We request this to be able to know why people would choose not to use the services provided by SixXS and the participating ISP's. THIS SOFTWARE IS PROVIDED BY SIXXS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SIXXS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. aiccu/doc/README0000644000175200017530000000310010114402546010504 00000000000000SixXS AICCU: Automatic IPv6 Connectivity Configuration Utility ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ AICCU makes it very easy for anybody to get IPv6 connectivity everywhere they want. It uses the TIC (Tunnel Information & Control) protocol to request the information needed to setup a tunnel through which the connectivity is created. AICCU supports the following tunneling protocols: - 6in4 static (RFC 2893) - 6in4 heartbeat (RFC 2893 + draft-massar-v6ops-heartbeat) - tinc (http://www.tinc-vpn.org) - AYIYA (draft-massar-v6ops-ayiya) As AYIYA even works from behind NAT's, thus unless there is a very restrictive firewall in place, anybody should be able to get IPv6 connectivity without problems and everywhere they want. The main AICCU page, containing information, screenshots, updates and of course the software itself, unix source + binaries/packages and Windows binaries, can be downloaded from: http://www.sixxs.net/tools/aiccu/ Author ~~~~~~ The author of this code is: Jeroen Massar SixXS Staff http://www.sixxs.net Contact ~~~~~~~ In the event that you find bugs or have questions then see: http://www.sixxs.net/contact/ which contains the contact details of the SixXS Staff. If you have problems using this tool you should of course first check the FAQ at http://www.sixxs.net/faq/ and check the Forum which can be found at http://www.sixxs.net/forum/ License ~~~~~~~ See the LICENSE file in the doc directory Copyright ~~~~~~~~~ Automatic IPv6 Connectivity Configuration Utility AICCU (C) Copyright 2003-2004 SixXS aiccu/doc/aiccu.conf0000644000175200017530000000055210117655504011576 00000000000000# AICCU Configuration # Login information #username #password # Interface names to use ipv4_interface eth0 ipv6_interface sixxs # The tunnel_id to use # (only required when there are multiple tunnels in the list) tunnel_id Txxxx # Be verbose? verbose false # Daemonize? daemonize true # Automatic? automatic true aiccu/doc/aiccu.init.freebsd0000755000175200017530000000100410117656070013220 00000000000000#!/bin/sh # # $FreeBSD$ # # PROVIDE: sixxs-aiccu # REQUIRE: NETWORKING # KEYWORD: FreeBSD # # Add the following lines to /etc/rc.conf to enable sixxs-aiccu: # #sixxs_aiccu_enable="YES" # . %%RC_SUBR%% name=sixxs_aiccu rcvar=`set_rcvar` command="%%PREFIX%%/sbin/sixxs-aiccu start" command_args=%%PREFIX%%/etc/aiccu.conf stop_cmd="%%PREFIX%%/sbin/sixxs-aiccu stop" required_files=%%PREFIX%%/etc/aiccu.conf # set default sixxs_aiccu_enable=${sixxs_aiccu_enable:-"NO"} load_rc_config ${name} run_rc_command "$1" aiccu/doc/aiccu.init.gentoo0000644000175200017530000000133110123077720013075 00000000000000#!/sbin/runscript depend() { need net } checkconfig() { # Verify that the configuration file exists if [ ! -f /etc/aiccu.conf ]; then eerror "AICCU Configuration file /etc/aiccu.conf doesn't exist" return 1 fi # Verify that the configuration is correct if [ `grep -c "^username" /etc/aiccu.conf 2>/dev/null` -ne 1 ]; then eerror "AICCU is not configured, edit /etc/aiccu.conf first" return 1 fi } start() { checkconfig || return 1 ebegin "Starting aiccu" start-stop-daemon --start --oknodo --quiet --exec /usr/sbin/aiccu -- start eend $? } stop() { ebegin "Stopping aiccu" start-stop-daemon --stop --oknodo --quiet --exec /usr/sbin/aiccu -- stop eend $? } aiccu/doc/COPYRIGHT0000664000175200017530000000030210134705037011125 00000000000000The code for AICCU was written by Jeroen Massar The copyright for this package is owned by SixXS. (C) Copyright SixXS 2004 All Rights Reserved Website: http://www.sixxs.net aiccu/doc/aiccu.sgml0000644000175200017530000001107610142107542011606 00000000000000 manpage.1'. You may view the manual page with: `docbook-to-man manpage.sgml | nroff -man | less'. A typical entry in a Makefile or Makefile.am is: manpage.1: manpage.sgml docbook-to-man $< > $@ --> Jeroen"> Massar"> October 27, 2004"> 1"> jeroen@sixxs.net"> AICCU"> Debian GNU/Linux"> GNU"> ]>
&dhemail;
&dhfirstname; &dhsurname; 2004 &dhusername; &dhdate; &dhucpackage; &dhsection; &dhpackage; Automatic IPv6 Connectivity Configuration Utility aiccu <start|stop|test|autotest|license> config DESCRIPTION AICCU makes it very easy for anybody to get IPv6 connectivity everywhere they want. It uses the TIC (Tunnel Information & Control) protocol to request the information needed to setup a tunnel through which the connectivity is created. AICCU supports the following tunneling protocols: - 6in4 static (RFC 2893) - 6in4 heartbeat (RFC 2893 + draft-massar-v6ops-heartbeat) - tinc (http://www.tinc-vpn.org) - AYIYA (draft-massar-v6ops-ayiya) As AYIYA even works from behind NAT's, thus unless there is a very restrictive firewall in place, anybody should be able to get IPv6 connectivity without problems and everywhere they want. OPTIONS start Starts aiccu service. stop Stops aiccu service. test Builds the connection and runs a simple selftest allowing a user to report this back as it should show most obvious problems. autotest Decription here license Shows the license aiccu is released under. config Read the configuration from config file. SEE ALSO The AICCU page at sixxs. AUTHOR AICCU was written by Jeroen Massar with contributions supplied a number of people as mentioned in the Changelog. aiccu/doc/aiccu.10000664000175200017530000000475710142107543011017 00000000000000.\" $Header: /aolnet/dev/src/CVS/sgml/docbook-to-man/cmd/docbook-to-man.sh,v 1.1.1.1 1998/11/13 21:31:59 db3l Exp $ .\" .\" transcript compatibility for postscript use. .\" .\" synopsis: .P! .\" .de P! .fl \!!1 setgray .fl \\&.\" .fl \!!0 setgray .fl \" force out current output buffer \!!save /psv exch def currentpoint translate 0 0 moveto \!!/showpage{}def .fl \" prolog .sy sed \-e 's/^/!/' \\$1\" bring in postscript file \!!psv restore . .de pF .ie \\*(f1 .ds f1 \\n(.f .el .ie \\*(f2 .ds f2 \\n(.f .el .ie \\*(f3 .ds f3 \\n(.f .el .ie \\*(f4 .ds f4 \\n(.f .el .tm ? font overflow .ft \\$1 .. .de fP .ie !\\*(f4 \{\ . ft \\*(f4 . ds f4\" ' br \} .el .ie !\\*(f3 \{\ . ft \\*(f3 . ds f3\" ' br \} .el .ie !\\*(f2 \{\ . ft \\*(f2 . ds f2\" ' br \} .el .ie !\\*(f1 \{\ . ft \\*(f1 . ds f1\" ' br \} .el .tm ? font underflow .. .ds f1\" .ds f2\" .ds f3\" .ds f4\" '\" t .ta 8n 16n 24n 32n 40n 48n 56n 64n 72n .TH "AICCU" "1" .SH "NAME" AICCU \(em Automatic IPv6 Connectivity Configuration Utility .SH "SYNOPSIS" .PP \fBaiccu \fR [\fIconfig\fR] .SH "DESCRIPTION" .PP AICCU makes it very easy for anybody to get IPv6 connectivity everywhere they want. It uses the TIC (Tunnel Information & Control) protocol to request the information needed to setup a tunnel through which the connectivity is created. AICCU supports the following tunneling protocols: - 6in4 static (RFC 2893) - 6in4 heartbeat (RFC 2893 + draft-massar-v6ops-heartbeat) - tinc (http://www.tinc-vpn.org) - AYIYA (draft-massar-v6ops-ayiya) As AYIYA even works from behind NAT's, thus unless there is a very restrictive firewall in place, anybody should be able to get IPv6 connectivity without problems and everywhere they want. .SH "OPTIONS" .IP "start" 10 Starts aiccu service. .IP "stop" 10 Stops aiccu service. .IP "test" 10 Builds the connection and runs a simple selftest allowing a user to report this back as it should show most obvious problems. .IP "autotest" 10 Decription here .IP "license" 10 Shows the license aiccu is released under. .IP "\fIconfig\fR" 10 Read the configuration from \fIconfig\fR file. .SH "SEE ALSO" .PP The AICCU \fIpage (link to URL http://www.sixxs.net/tools/aiccu/) \fR at sixxs. .SH "AUTHOR" .PP AICCU was written by Jeroen Massar with contributions supplied a number of people as mentioned in the Changelog. .\" created by instant / docbook-to-man, Wed 03 Nov 2004, 08:57 aiccu/rpm/0000775000175200017530000000000010115342401007737 500000000000000aiccu/rpm/aiccu.spec0000664000175200017530000000352510114431013011621 00000000000000############################################################ # AICCU - Automatic IPv6 Connectivity Client Utility # by Jeroen Massar # (c) Copyright 2003-2004 SixXS ############################################################ # AICCU RPM Spec File ############################################################ %if %{?aiccu_version:0}%{!?aiccu_version:1} %define aiccu_version rpmbuild %endif %if %{?aiccu_release:0}%{!?aiccu_release:1} %define aiccu_release 1 %endif %if %{?srcext:0}%{!?srcext:1} %define srcext .gz %endif Summary: AICCU - SixXS Automatic IPv6 Connectivity Client Utility Name: aiccu Version: %(version=`echo %{aiccu_version} | cut -b0-10`; echo ${version}) Release: %(options=`echo %{aiccu_version} | cut -b12-`; echo %{aiccu_release}${options}) License: GPL Group: Networking/Utilities URL: http://www.sixxs.net/tools/aiccu/ Vendor: SixXS BuildRoot: /var/tmp/%{name}-root Packager: SixXS Source: aiccu_%{aiccu_version}.tar%{srcext} %description This client automatically gives one IPv6 connectivity without having to manually configure interfaces etc. One does need a SixXS account and at least a tunnel. These can be freely & gratis requested from the SixXS website. For more information about SixXS check http://www.sixxs.net %prep %setup -q -n %{name} %build make RPM_OPT_FLAGS="$RPM_OPT_FLAGS" %install if [ -n "$RPM_BUILD_ROOT" ] ; then [ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT fi mkdir -p $RPM_BUILD_ROOT make install DESTDIR=$RPM_BUILD_ROOT %clean make clean rm -rf $RPM_BUILD_ROOT %files %defattr(-,root,root) %doc doc/README doc/LICENSE %{_sbindir}/aiccu %config %{_sysconfdir}/aiccu.conf %config %{_sysconfdir}/init.d/aiccu %changelog * Sun Aug 29 2004 Jeroen Massar 2004.08.29 - Beta2 with TIC, 6in4, 6in4-heartbeat and AYIYA support aiccu/unix-console/0000775000175200017530000000000010160264732011576 500000000000000aiccu/unix-console/Makefile0000775000175200017530000000506510140407431013160 00000000000000# /********************************************************** # SixXS - Automatic IPv6 Connectivity Configuration Utility # *********************************************************** # Copyright 2003-2004 SixXS - http://www.sixxs.net # *********************************************************** # unix-client/Makefile - Makefile for the UNIX client # *********************************************************** # $Author: jeroen $ # $Id: Makefile,v 1.5 2004/10/29 09:36:25 jeroen Exp $ # $Date: 2004/10/29 09:36:25 $ # **********************************************************/ SRCS = main.c ../common/aiccu.c ../common/hash_md5.c ../common/hash_sha1.c ../common/common.c ../common/heartbeat.c ../common/tic.c ../common/ayiya.c ../common/aiccu_test.c INCS = ../common/aiccu.h ../common/hash_md5.h ../common/hash_sha1.h ../common/common.h ../common/heartbeat.h ../common/tic.h ../common/ayiya.h OBJS = main.o ../common/aiccu.o ../common/hash_md5.o ../common/hash_sha1.o ../common/common.o ../common/heartbeat.o ../common/tic.o ../common/ayiya.o ../common/aiccu_test.o CWARNS = -pedantic -W -Wall -Wshadow -Wcast-align #CFLAGS += $(CWARNS) -D_GNU_SOURCE -D_DEBUG -g3 -O0 CFLAGS += $(CWARNS) -D _GNU_SOURCE -O3 CC = gcc RM = rm # Linux ifeq ($(shell uname | grep -c "Linux"),1) CWARNS += -Wpadded -Wpacked SRCS += ../common/aiccu_linux.c OBJS += ../common/aiccu_linux.o LDFLAGS = -lpthread endif # FreeBSD 4.x ifeq ($(shell uname | grep -c "FreeBSD"),1) # FreeBSD 4.x ifeq ($(shell uname -r | cut -c 1),4) SRCS += ../common/aiccu_freebsd4.c OBJS += ../common/aiccu_freebsd4.o CFLAGS += -pthread endif # FreeBSD 5.x ifeq ($(shell uname -r | cut -c 1),5) SRCS += ../common/aiccu_kame.c OBJS += ../common/aiccu_kame.o CFLAGS += -pthread endif endif # NetBSD ifeq ($(shell uname | grep -c "NetBSD"),1) SRCS += ../common/aiccu_kame.c OBJS += ../common/aiccu_kame.o CFLAGS += -pthread endif # OpenBSD ifeq ($(shell uname | grep -c "OpenBSD"),1) # 2.7-2.9 ifeq ($(shell uname -r | cut -c 1),2) SRCS += ../common/aiccu_openbsd2.c OBJS += ../common/aiccu_openbsd2.o endif # 3.x ifeq ($(shell uname -r | cut -c 1),3) SRCS += ../common/aiccu_openbsd.c OBJS += ../common/aiccu_openbsd.o endif CFLAGS += -pthread endif # Darwin ifeq ($(shell uname | grep -c "Darwin"),1) SRCS += ../common/aiccu_darwin.c OBJS += ../common/aiccu_darwin.o CFLAGS += -DDARWIN endif all: aiccu aiccu: $(OBJS) ${INCS} $(CC) $(CFLAGS) -o $@ $(OBJS) $(LDFLAGS); ifeq ($(shell echo $(CFLAGS) | grep -c "DEBUG"),0) strip $@ endif clean: $(RM) -f $(OBJS) aiccu install: aiccu cp aiccu ${DESTDIR}${dirsbin}aiccu aiccu/unix-console/main.c0000775000175200017530000001320710140406531012605 00000000000000/********************************************************** SixXS - Automatic IPv6 Connectivity Configuration Utility *********************************************************** Copyright 2003-2004 SixXS - http://www.sixxs.net *********************************************************** unix-client/aiccu.c - AICCU - The client for UNIX *********************************************************** $Author: jeroen $ $Id: main.c,v 1.3 2004/10/29 09:28:57 jeroen Exp $ $Date: 2004/10/29 09:28:57 $ **********************************************************/ #include "../common/aiccu.h" /* * AICCU! - Aka... let's get connected ;) * returns a TIC_Tunnel which can then be * used for configuring and keeping it running */ struct TIC_Tunnel *get_tunnel() { struct TIC_sTunnel *hsTunnel, *t; struct TIC_Tunnel *hTunnel; /* Login to the TIC Server */ if (!tic_Login(g_aiccu->tic, g_aiccu->username, g_aiccu->password)) return false; /* * Don't try to list the tunnels when * we already have a tunnel_id configured */ if (!g_aiccu->tunnel_id) { hsTunnel = tic_ListTunnels(g_aiccu->tic); if (!hsTunnel) { dolog(LOG_ERR, "No tunnel available, request one first\n"); tic_Free_sTunnel(hsTunnel); tic_Logout(g_aiccu->tic); return NULL; } if (hsTunnel->next) { dolog(LOG_ERR, "Multiple tunnels available, please pick one from the following list and configure the aiccu.conf using it\n"); for (t = hsTunnel; t; t = t->next) { dolog(LOG_ERR, "%s %s %s %s\n", t->sId, t->sIPv6, t->sIPv4, t->sPOPId); } tic_Free_sTunnel(hsTunnel); tic_Logout(g_aiccu->tic); return NULL; } g_aiccu->tunnel_id = strdup(hsTunnel->sId); /* Free the info */ tic_Free_sTunnel(hsTunnel); } /* Get Tunnel Information */ hTunnel = tic_GetTunnel(g_aiccu->tic, g_aiccu->tunnel_id); if (!hTunnel) { tic_Logout(g_aiccu->tic); return NULL; } /* Logout, TIC is not needed any more */ tic_Logout(g_aiccu->tic); /* Swee.... sufficient information */ return hTunnel; } enum AICCU_MODES { A_NONE = 0, A_START, A_STOP, A_TEST, A_AUTOTEST, A_LICENSE }; int main(int argc, char *argv[]) { enum AICCU_MODES mode = A_NONE; struct TIC_Tunnel *hTunnel; #ifdef _WIN32 WSADATA wsadata; /* Initialize Winsock so that we can do network functions */ WSAStartup(WINSOCK_VERSION, &wsadata); #endif /* Initialize Configuration */ aiccu_InitConfig(); /* Make sure we actually have an IPv6 stack */ aiccu_install(); /* Require start/stop/test */ if (argc == 2 || argc == 3) { if (strcasecmp(argv[1], "start") == 0) mode = A_START; else if (strcasecmp(argv[1], "stop") == 0) mode = A_STOP; else if (strcasecmp(argv[1], "test") == 0) mode = A_TEST; else if (strcasecmp(argv[1], "autotest")== 0) mode = A_AUTOTEST; else if (strcasecmp(argv[1], "license") == 0) mode = A_LICENSE; } /* Optionally we want a second argument: a config file */ if (( argc != 2 && argc != 3) || mode == A_NONE) { dolog(LOG_ERR, "aiccu (start|stop|test|autotest|license) []\n"); return -1; } if ( mode == A_LICENSE) { printf("%s\n", aiccu_license()); return 0; } #ifndef _WIN32 /* start or stop? */ if ( mode != A_TEST && mode != A_AUTOTEST) { /* Already running? */ if (sigrunning(mode == A_STOP ? SIGTERM : SIGHUP) == 1) { dolog(LOG_ERR, "Already running instance HUP'ed, exiting\n"); return 0; } } #endif /* Load a configuration file */ if (!aiccu_LoadConfig(argc == 2 ? AICCU_CONFIG : argv[2])) { return -1; } /* Verify required parameters */ if (!g_aiccu->username || !g_aiccu->password) { dolog(LOG_ERR, "Required parameters missing, make sure that username and password are given\n"); aiccu_FreeConfig(); return false; } /* Get our tunnel */ hTunnel = get_tunnel(g_aiccu->tic); if (!hTunnel) { dolog(LOG_ERR, "Couldn't retrieve first tunnel for the above reason, aborting\n"); aiccu_FreeConfig(); return -1; } /* * We now have sufficient information. * Thus we can logout from the TIC server */ tic_Logout(g_aiccu->tic); g_aiccu->tic = NULL; if (g_aiccu->verbose) { printf("Tunnel Information for %s:\n",hTunnel->sId); printf("POP Id : %s\n", hTunnel->sPOP_Id); printf("IPv6 Local : %s/%u\n", hTunnel->sIPv6_Local,hTunnel->nIPv6_PrefixLength); printf("IPv6 Remote : %s/%u\n", hTunnel->sIPv6_POP,hTunnel->nIPv6_PrefixLength); printf("Tunnel Type : %s\n", hTunnel->sType); printf("Adminstate : %s\n", hTunnel->sAdminState); printf("Userstate : %s\n", hTunnel->sUserState); } /* Do the test thing */ if ( mode == A_TEST || mode == A_AUTOTEST) { aiccu_test(hTunnel, strcasecmp(argv[1], "autotest") == 0 ? true : false); /* exit as all is done */ tic_Free_Tunnel(hTunnel); aiccu_FreeConfig(); return 0; } #ifndef _WIN32 if ( mode == A_START && g_aiccu->daemonize != 0) { /* Daemonize */ int i = fork(); if (i < 0) { fprintf(stderr, "Couldn't fork\n"); return -1; } /* Exit the mother fork */ if (i != 0) return 0; /* Child fork */ setsid(); /* Cleanup stdin/out/err */ freopen("/dev/null","r",stdin); freopen("/dev/null","w",stdout); freopen("/dev/null","w",stderr); savepid(); } #endif /* !_WIN32 */ if (mode == A_STOP) { aiccu_delete(hTunnel); /* Free stuff and exit */ tic_Free_Tunnel(hTunnel); aiccu_FreeConfig(); return 0; } /* mode == A_START */ /* * Setup our tunnel * This also spawns required threads for AYIYA */ aiccu_setup(hTunnel, true); /* We are spawned, now just beat once in a while. */ while (strcmp(hTunnel->sType, "6in4-heartbeat") == 0) { dolog(LOG_DEBUG, "Beat()\n"); heartbeat_beat(hTunnel); sleep(hTunnel->nHeartbeat_Interval); } aiccu_FreeConfig(); return 0; } aiccu/freebsd/0000775000175200017530000000000010160264724010566 500000000000000aiccu/freebsd/pkg-plist0000664000175200017530000000022710117654713012347 00000000000000@comment $FreeBSD$ etc/rc.d/sixxs-aiccu.sh etc/aiccu.conf.sample sbin/sixxs-aiccu %%DOCSDIR%%/README %%EXAMPLESDIR%%/aiccu.conf @dirrm %%EXAMPLESDIR%% aiccu/freebsd/pkg-descr0000664000175200017530000000174710117655540012323 00000000000000SixXS AICCU: Automatic IPv6 Connectivity Configuration Utility ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ AICCU makes it very easy for anybody to get IPv6 connectivity everywhere they want. It uses the TIC (Tunnel Information & Control) protocol to request the information needed to setup a tunnel through which the connectivity is created. AICCU supports the following tunneling protocols: - 6in4 static (RFC 2893) - 6in4 heartbeat (RFC 2893 + draft-massar-v6ops-heartbeat) - tinc (http://www.tinc-vpn.org) - AYIYA (draft-massar-v6ops-ayiya) As AYIYA even works from behind NAT's, thus unless there is a very restrictive firewall in place, anybody should be able to get IPv6 connectivity without problems and everywhere they want. The main AICCU page, containing information, screenshots, updates and of course the software itself, unix source + binaries/packages and Windows binaries, can be downloaded from: WWW: http://www.sixxs.net/tools/aiccu/ aiccu/freebsd/Makefile0000664000175200017530000000317310160264621012146 00000000000000# New ports collection makefile for: sixxs-aiccu # Date created: 2004-09-09 # Initial FreeBSD port by: Meno Abels # Comments for this port please to the SixXS staff # # $FreeBSD$ # PORTNAME= sixxs-aiccu PORTVERSION= 20041216 PORTREVISION= 1 CATEGORIES= net ipv6 MASTER_SITES= http://www.sixxs.net/archive/sixxs/aiccu/unix/ DISTFILES= aiccu_current.tgz MAINTAINER= info@sixxs.net COMMENT= Automatic IPv6 Connectivity Configuration Utility (AICCU) USE_RC_SUBR= yes USE_GMAKE= yes WRKSRC= ${WRKDIR}/aiccu pre-build: @${SED} -e 's:%%PREFIX%%:${PREFIX}:g' \ -e 's:%%RC_SUBR%%:${RC_SUBR}:g' \ ${WRKSRC}/doc/aiccu.init.freebsd >${WRKDIR}/aiccu.init.freebsd @${SED} \ -e 's:ipv4_interface eth0:ipv4_interface sis0:' \ -e 's:ipv6_interface sixxs:ipv6_interface gif0:' \ ${WRKSRC}/doc/aiccu.conf > ${WRKDIR}/aiccu.conf do-install: @${MKDIR} ${DOCSDIR} ${EXAMPLESDIR} ${INSTALL_PROGRAM} ${WRKSRC}/unix-console/aiccu ${PREFIX}/sbin/sixxs-aiccu ${INSTALL_DATA} ${WRKSRC}/doc/README ${DOCSDIR} ${INSTALL_DATA} ${WRKSRC}/doc/LICENSE ${DOCSDIR} ${INSTALL_DATA} ${WRKSRC}/doc/HOWTO ${DOCSDIR} ${INSTALL_DATA} ${WRKSRC}/doc/aiccu.conf ${EXAMPLESDIR} ${INSTALL_DATA} ${WRKDIR}/aiccu.conf ${PREFIX}/etc/aiccu.conf.sample ${INSTALL_SCRIPT} ${WRKDIR}/aiccu.init.freebsd ${PREFIX}/etc/rc.d/aiccu.sh post-install: if [ \! -f ${PREFIX}/etc/aiccu.conf ]; then \ ${MV} ${PREFIX}/etc/aiccu.conf.sample ${PREFIX}/etc/aiccu.conf.sample; \ fi .include .if ${OSVERSION} > 501100 GIFCONFIG= netbsd .else GIFCONFIG= freebsd .endif .include aiccu/gentoo/0000755000175200017530000000000010123077705010445 500000000000000aiccu/gentoo/aiccu-ebuild0000644000175200017530000000140310122511023012615 00000000000000DESCRIPTION="AICCU Client to configure an IPv6 tunnel to SixXS" HOMEPAGE="http://www.sixxs.net/" SRC_URI="http://www.sixxs.net/archive/sixxs/aiccu/unix/aiccu_current.tar.gz" LICENSE="SixXS" SLOT="0" KEYWORDS="~x86" IUSE="" DEPEND="" S=${WORKDIR}/aiccu src_compile() { cd ${S} export RPM_OPT_FLAGS=${CFLAGS} make || die "Build Failed" } src_install() { dosbin unix-console/aiccu insopts -m 600 insinto /etc doins aiccu.conf dodoc doc/{HOWTO,LICENSE,README,changelog} exeinto /etc/init.d newexe doc/aiccu.init.gentoo aiccu } pkg_postinst() { einfo "The aiccu ebuild installs an init script named 'aiccu'" einfo "To add support for a SixXS connection at startup, do" einfo "edit your /etc/aiccu.conf and do" einfo "# rc-update add aiccu default" }