github/ZeroTierOne
1
0
Fork 0
mirror of https://github.com/ZeroTier/ZeroTierOne synced 2025-08-21 05:43:59 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

Add some historic code just for the heck of it.

Browse source
This commit is contained in:
Adam Ierymenko 2017-05-04 10:42:22 -07:00
commit 54c47a1e03
50 changed files with 8064 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

72
attic/historic/anode/libanode/impl/aes.c Normal file
View file

@ -0,0 +1,72 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "aes.h"
void Anode_cmac_aes256(
const AnodeAesExpandedKey *expkey,
const unsigned char *restrict data,
unsigned long data_len,
unsigned char *restrict mac)
{
unsigned char cbc[16];
unsigned char pad[16];
const unsigned char *restrict pos = data;
unsigned long i;
unsigned long remaining = data_len;
unsigned char c;
((uint64_t *)((void *)cbc))[0] = 0ULL;
((uint64_t *)((void *)cbc))[1] = 0ULL;
while (remaining >= 16) {
((uint64_t *)((void *)cbc))[0] ^= ((uint64_t *)((void *)pos))[0];
((uint64_t *)((void *)cbc))[1] ^= ((uint64_t *)((void *)pos))[1];
pos += 16;
if (remaining > 16)
Anode_aes256_encrypt(expkey,cbc,cbc);
remaining -= 16;
}
((uint64_t *)((void *)pad))[0] = 0ULL;
((uint64_t *)((void *)pad))[1] = 0ULL;
Anode_aes256_encrypt(expkey,pad,pad);
c = pad[0] & 0x80;
for(i=0;i<15;++i)
pad[i] = (pad[i] << 1) | (pad[i + 1] >> 7);
pad[15] <<= 1;
if (c)
pad[15] ^= 0x87;
if (remaining||(!data_len)) {
for(i=0;i<remaining;++i)
cbc[i] ^= *(pos++);
cbc[remaining] ^= 0x80;
c = pad[0] & 0x80;
for(i=0;i<15;++i)
pad[i] = (pad[i] << 1) | (pad[i + 1] >> 7);
pad[15] <<= 1;
if (c)
pad[15] ^= 0x87;
}
((uint64_t *)((void *)mac))[0] = ((uint64_t *)((void *)pad))[0] ^ ((uint64_t *)((void *)cbc))[0];
((uint64_t *)((void *)mac))[1] = ((uint64_t *)((void *)pad))[1] ^ ((uint64_t *)((void *)cbc))[1];
Anode_aes256_encrypt(expkey,mac,mac);
}

64
attic/historic/anode/libanode/impl/aes.h Normal file
View file

@ -0,0 +1,64 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef _ANODE_AES_H
#define _ANODE_AES_H
#include <openssl/aes.h>
#include "types.h"
/* This just glues us to OpenSSL's built-in AES-256 implementation */
#define ANODE_AES_BLOCK_SIZE 16
#define ANODE_AES_KEY_SIZE 32
typedef AES_KEY AnodeAesExpandedKey;
#define Anode_aes256_expand_key(k,ek) AES_set_encrypt_key((const unsigned char *)(k),256,(AES_KEY *)(ek))
/* Note: in and out can be the same thing */
#define Anode_aes256_encrypt(ek,in,out) AES_encrypt((const unsigned char *)(in),(unsigned char *)(out),(const AES_KEY *)(ek))
/* Note: iv is modified */
static inline void Anode_aes256_cfb_encrypt(
const AnodeAesExpandedKey *expkey,
const unsigned char *in,
unsigned char *out,
unsigned char *iv,
unsigned long len)
{
int tmp = 0;
AES_cfb128_encrypt(in,out,len,(const AES_KEY *)expkey,iv,&tmp,AES_ENCRYPT);
}
static inline void Anode_aes256_cfb_decrypt(
const AnodeAesExpandedKey *expkey,
const unsigned char *in,
unsigned char *out,
unsigned char *iv,
unsigned long len)
{
int tmp = 0;
AES_cfb128_encrypt(in,out,len,(const AES_KEY *)expkey,iv,&tmp,AES_DECRYPT);
}
/* CMAC message authentication code */
void Anode_cmac_aes256(
const AnodeAesExpandedKey *expkey,
const unsigned char *restrict data,
unsigned long data_len,
unsigned char *restrict mac);
#endif

239
attic/historic/anode/libanode/impl/dictionary.c Normal file
View file

@ -0,0 +1,239 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
#include "dictionary.h"
static const char *EMPTY_STR = "";
void AnodeDictionary_clear(struct AnodeDictionary *d)
{
struct AnodeDictionaryEntry *e,*ne;
int oldcs;
unsigned int i;
oldcs = d->case_sensitive;
for(i=0;i<ANODE_DICTIONARY_FIXED_HASH_TABLE_SIZE;++i) {
e = d->ht[i];
while (e) {
ne = e->next;
if ((e->key)&&(e->key != EMPTY_STR)) free((void *)e->key);
if ((e->value)&&(e->value != EMPTY_STR)) free((void *)e->value);
free((void *)e);
e = ne;
}
}
Anode_zero((void *)d,sizeof(struct AnodeDictionary));
d->case_sensitive = oldcs;
}
void AnodeDictionary_put(struct AnodeDictionary *d,const char *key,const char *value)
{
struct AnodeDictionaryEntry *e;
char *p1;
const char *p2;
unsigned int bucket = (d->case_sensitive) ? AnodeDictionary__get_bucket(key) : AnodeDictionary__get_bucket_ci(key);
unsigned int len,i;
e = d->ht[bucket];
while (e) {
if (((d->case_sensitive) ? Anode_streq(key,e->key) : Anode_strcaseeq(key,e->key))) {
if (!d->case_sensitive) {
p1 = e->key;
p2 = key;
while (*p2) *(p1++) = *(p2++);
}
len = 0;
while (value[len]) ++len;
if (len) {
if ((e->value)&&(e->value != EMPTY_STR))
e->value = (char *)realloc((void *)e->value,len + 1);
else e->value = (char *)malloc(len + 1);
for(i=0;i<len;++i) e->value[i] = value[i];
e->value[i] = (char)0;
} else {
if ((e->value)&&(e->value != EMPTY_STR)) free((void *)e->value);
e->value = (char *)EMPTY_STR;
}
return;
}
e = e->next;
}
e = (struct AnodeDictionaryEntry *)malloc(sizeof(struct AnodeDictionaryEntry));
len = 0;
while (key[len]) ++len;
if (len) {
e->key = (char *)malloc(len + 1);
for(i=0;i<len;++i) e->key[i] = key[i];
e->key[i] = (char)0;
} else e->key = (char *)EMPTY_STR;
len = 0;
while (value[len]) ++len;
if (len) {
e->value = (char *)malloc(len + 1);
for(i=0;i<len;++i) e->value[i] = value[i];
e->value[i] = (char)0;
} else e->value = (char *)EMPTY_STR;
e->next = d->ht[bucket];
d->ht[bucket] = e;
++d->size;
}
void AnodeDictionary_read(
struct AnodeDictionary *d,
char *in,
const char *line_breaks,
const char *kv_breaks,
const char *comment_chars,
char escape_char,
int trim_whitespace_from_keys,
int trim_whitespace_from_values)
{
char *line = in;
char *key;
char *value;
char *p1,*p2,*p3;
char last = ~escape_char;
int eof_state = 0;
for(;;) {
if ((!*in)||((Anode_strchr(line_breaks,*in))&&((last != escape_char)||(!escape_char)))) {
if (!*in)
eof_state = 1;
else *in = (char)0;
if ((*line)&&((comment_chars)&&(!Anode_strchr(comment_chars,*line)))) {
key = line;
while (*line) {
if ((Anode_strchr(kv_breaks,*line))&&((last != escape_char)||(!escape_char))) {
*(line++) = (char)0;
break;
} else last = *(line++);
}
while ((*line)&&(Anode_strchr(kv_breaks,*line))&&((last != escape_char)||(!escape_char)))
last = *(line++);
value = line;
if (escape_char) {
p1 = key;
while (*p1) {
if (*p1 == escape_char) {
p2 = p1;
p3 = p1 + 1;
while (*p3)
*(p2++) = *(p3++);
*p2 = (char)0;
}
++p1;
}
p1 = value;
while (*p1) {
if (*p1 == escape_char) {
p2 = p1;
p3 = p1 + 1;
while (*p3)
*(p2++) = *(p3++);
*p2 = (char)0;
}
++p1;
}
}
if (trim_whitespace_from_keys)
Anode_trim(key);
if (trim_whitespace_from_values)
Anode_trim(value);
AnodeDictionary_put(d,key,value);
}
if (eof_state)
break;
else line = in + 1;
}
last = *(in++);
}
}
long AnodeDictionary_write(
struct AnodeDictionary *d,
char *out,
long out_size,
const char *line_break,
const char *kv_break)
{
struct AnodeDictionaryEntry *e;
const char *tmp;
long ptr = 0;
unsigned int bucket;
if (out_size <= 0)
return -1;
for(bucket=0;bucket<ANODE_DICTIONARY_FIXED_HASH_TABLE_SIZE;++bucket) {
e = d->ht[bucket];
while (e) {
tmp = e->key;
if (tmp) {
while (*tmp) {
out[ptr++] = *tmp++;
if (ptr >= (out_size - 1)) return -1;
}
}
tmp = kv_break;
if (tmp) {
while (*tmp) {
out[ptr++] = *tmp++;
if (ptr >= (out_size - 1)) return -1;
}
}
tmp = e->value;
if (tmp) {
while (*tmp) {
out[ptr++] = *tmp++;
if (ptr >= (out_size - 1)) return -1;
}
}
tmp = line_break;
if (tmp) {
while (*tmp) {
out[ptr++] = *tmp++;
if (ptr >= (out_size - 1)) return -1;
}
}
e = e->next;
}
}
out[ptr] = (char)0;
return ptr;
}

126
attic/historic/anode/libanode/impl/dictionary.h Normal file
View file

@ -0,0 +1,126 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* This is a simple string hash table suitable for small tables such as zone
* files or HTTP header lists. */
#ifndef _ANODE_DICTIONARY_H
#define _ANODE_DICTIONARY_H
#include "misc.h"
/* This is a fixed hash table and is designed for relatively small numbers
* of keys for things like zone files. */
#define ANODE_DICTIONARY_FIXED_HASH_TABLE_SIZE 16
#define ANODE_DICTIONARY_FIXED_HASH_TABLE_MASK 15
/* Computes a hash code for a string and returns the hash bucket */
static inline unsigned int AnodeDictionary__get_bucket(const char *s)
{
unsigned int hc = 3;
while (*s)
hc = ((hc << 4) + hc) + (unsigned int)*(s++);
return ((hc ^ (hc >> 4)) & ANODE_DICTIONARY_FIXED_HASH_TABLE_MASK);
}
/* Case insensitive version of get_bucket */
static inline unsigned int AnodeDictionary__get_bucket_ci(const char *s)
{
unsigned int hc = 3;
while (*s)
hc = ((hc << 4) + hc) + (unsigned int)Anode_tolower(*(s++));
return ((hc ^ (hc >> 4)) & ANODE_DICTIONARY_FIXED_HASH_TABLE_MASK);
}
struct AnodeDictionaryEntry
{
char *key;
char *value;
struct AnodeDictionaryEntry *next;
};
struct AnodeDictionary
{
struct AnodeDictionaryEntry *ht[ANODE_DICTIONARY_FIXED_HASH_TABLE_SIZE];
unsigned int size;
int case_sensitive;
};
static inline void AnodeDictionary_init(struct AnodeDictionary *d,int case_sensitive)
{
Anode_zero((void *)d,sizeof(struct AnodeDictionary));
d->case_sensitive = case_sensitive;
}
void AnodeDictionary_clear(struct AnodeDictionary *d);
static inline void AnodeDictionary_destroy(struct AnodeDictionary *d)
{
AnodeDictionary_clear(d);
}
void AnodeDictionary_put(struct AnodeDictionary *d,const char *key,const char *value);
static inline const char *AnodeDictionary_get(struct AnodeDictionary *d,const char *key)
{
struct AnodeDictionaryEntry *e;
unsigned int bucket = (d->case_sensitive) ? AnodeDictionary__get_bucket(key) : AnodeDictionary__get_bucket_ci(key);
e = d->ht[bucket];
while (e) {
if ((d->case_sensitive ? Anode_streq(key,e->key) : Anode_strcaseeq(key,e->key)))
return e->value;
e = e->next;
}
return (const char *)0;
}
static inline void AnodeDictionary_iterate(
struct AnodeDictionary *d,
void *arg,
int (*func)(void *,const char *,const char *))
{
struct AnodeDictionaryEntry *e;
unsigned int bucket;
for(bucket=0;bucket<ANODE_DICTIONARY_FIXED_HASH_TABLE_SIZE;++bucket) {
e = d->ht[bucket];
while (e) {
if (!func(arg,e->key,e->value))
return;
e = e->next;
}
}
}
void AnodeDictionary_read(
struct AnodeDictionary *d,
char *in,
const char *line_breaks,
const char *kv_breaks,
const char *comment_chars,
char escape_char,
int trim_whitespace_from_keys,
int trim_whitespace_from_values);
long AnodeDictionary_write(
struct AnodeDictionary *d,
char *out,
long out_size,
const char *line_break,
const char *kv_break);
#endif

93
attic/historic/anode/libanode/impl/dns_txt.c Normal file
View file

@ -0,0 +1,93 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <resolv.h>
#include <netdb.h>
#include "dns_txt.h"
#ifndef C_IN
#define C_IN ns_c_in
#endif
#ifndef T_TXT
#define T_TXT ns_t_txt
#endif
static volatile int Anode_resolver_initialized = 0;
int Anode_sync_resolve_txt(const char *host,char *txt,unsigned int txt_len)
{
unsigned char answer[16384],*pptr,*end;
char name[16384];
int len,explen,i;
if (!Anode_resolver_initialized) {
Anode_resolver_initialized = 1;
res_init();
}
/* Do not taunt happy fun ball. */
len = res_search(host,C_IN,T_TXT,answer,sizeof(answer));
if (len > 12) {
pptr = answer + 12;
end = answer + len;
explen = dn_expand(answer,end,pptr,name,sizeof(name));
if (explen > 0) {
pptr += explen;
if ((pptr + 2) >= end) return 2;
if (ntohs(*((uint16_t *)pptr)) == T_TXT) {
pptr += 4;
if (pptr >= end) return 2;
explen = dn_expand(answer,end,pptr,name,sizeof(name));
if (explen > 0) {
pptr += explen;
if ((pptr + 2) >= end) return 2;
if (ntohs(*((uint16_t *)pptr)) == T_TXT) {
pptr += 10;
if (pptr >= end) return 2;
len = *(pptr++);
if (len <= 0) return 2;
if ((pptr + len) > end) return 2;
if (txt_len < (len + 1))
return 4;
else {
for(i=0;i<len;++i)
txt[i] = pptr[i];
txt[len] = (char)0;
return 0;
}
}
}
}
}
}
return 1;
}

37
attic/historic/anode/libanode/impl/dns_txt.h Normal file
View file

@ -0,0 +1,37 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef _ANODE_DNS_TXT_H
#define _ANODE_DNS_TXT_H
/**
* Synchronous TXT resolver routine
*
* Error codes:
* 1 - I/O error
* 2 - Invalid response
* 3 - TXT record not found
* 4 - Destination buffer too small for result
*
* @param host Host name
* @param txt Buffer to store TXT result
* @param txt_len Size of buffer
* @return Zero on success, special error code on failure
*/
int Anode_sync_resolve_txt(const char *host,char *txt,unsigned int txt_len);
#endif

219
attic/historic/anode/libanode/impl/ec.c Normal file
View file

@ -0,0 +1,219 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/bn.h>
#include <openssl/obj_mac.h>
#include <openssl/rand.h>
#include <openssl/ec.h>
#include <openssl/ecdh.h>
#include <openssl/ecdsa.h>
#include "types.h"
#include "misc.h"
#include "ec.h"
static EC_GROUP *AnodeEC_group = (EC_GROUP *)0;
static void *AnodeEC_KDF(const void *in,size_t inlen,void *out,size_t *outlen)
{
unsigned long i,longest_length;
if (!*outlen)
return out;
for(i=0;i<(unsigned long)*outlen;++i)
((unsigned char *)out)[i] = (unsigned char)0;
longest_length = inlen;
if (longest_length < *outlen)
longest_length = *outlen;
for(i=0;i<longest_length;++i)
((unsigned char *)out)[i % (unsigned long)*outlen] ^= ((const unsigned char *)in)[i % (unsigned long)inlen];
return out;
}
int AnodeECKeyPair_generate(struct AnodeECKeyPair *pair)
{
EC_KEY *key;
int len;
#ifdef HAS_DEV_URANDOM
char buf[128];
FILE *f = fopen("/dev/urandom","r");
if (f) {
if (fread(buf,1,sizeof(buf),f) == sizeof(buf))
RAND_add(buf,sizeof(buf),sizeof(buf)/2);
fclose(f);
}
#endif
if (!AnodeEC_group) {
AnodeEC_group = EC_GROUP_new_by_curve_name(ANODE_EC_GROUP);
if (!AnodeEC_group) return 0;
}
key = EC_KEY_new();
if (!key) return 0;
if (!EC_KEY_set_group(key,AnodeEC_group)) {
EC_KEY_free(key);
return 0;
}
if (!EC_KEY_generate_key(key)) {
EC_KEY_free(key);
return 0;
}
Anode_zero(pair,sizeof(struct AnodeECKeyPair));
/* Stuff the private key into priv.key */
len = BN_num_bytes(EC_KEY_get0_private_key(key));
if ((len > ANODE_EC_PRIME_BYTES)||(len < 0)) {
EC_KEY_free(key);
return 0;
}
BN_bn2bin(EC_KEY_get0_private_key(key),&(pair->priv.key[ANODE_EC_PRIME_BYTES - len]));
pair->priv.bytes = ANODE_EC_PRIME_BYTES;
len = EC_POINT_point2oct(AnodeEC_group,EC_KEY_get0_public_key(key),POINT_CONVERSION_COMPRESSED,pair->pub.key,sizeof(pair->pub.key),0);
if (len != ANODE_EC_PUBLIC_KEY_BYTES) {
EC_KEY_free(key);
return 0;
}
pair->pub.bytes = ANODE_EC_PUBLIC_KEY_BYTES;
/* Keep a copy of OpenSSL's structure around so we don't have to re-init
* it every time we use our key pair structure. */
pair->internal_key = key;
return 1;
}
int AnodeECKeyPair_init(struct AnodeECKeyPair *pair,const struct AnodeECKey *pub,const struct AnodeECKey *priv)
{
EC_KEY *key;
EC_POINT *kxy;
BIGNUM *pn;
if (!AnodeEC_group) {
AnodeEC_group = EC_GROUP_new_by_curve_name(ANODE_EC_GROUP);
if (!AnodeEC_group) return 0;
}
key = EC_KEY_new();
if (!key)
return 0;
if (!EC_KEY_set_group(key,AnodeEC_group)) {
EC_KEY_free(key);
return 0;
}
/* Grab the private key */
if (priv->bytes != ANODE_EC_PRIME_BYTES) {
EC_KEY_free(key);
return 0;
}
pn = BN_new();
if (!pn) {
EC_KEY_free(key);
return 0;
}
if (!BN_bin2bn(priv->key,ANODE_EC_PRIME_BYTES,pn)) {
BN_free(pn);
EC_KEY_free(key);
return 0;
}
if (!EC_KEY_set_private_key(key,pn)) {
BN_free(pn);
EC_KEY_free(key);
return 0;
}
BN_free(pn);
/* Set the public key */
if (pub->bytes != ANODE_EC_PUBLIC_KEY_BYTES) {
EC_KEY_free(key);
return 0;
}
kxy = EC_POINT_new(AnodeEC_group);
if (!kxy) {
EC_KEY_free(key);
return 0;
}
EC_POINT_oct2point(AnodeEC_group,kxy,pub->key,ANODE_EC_PUBLIC_KEY_BYTES,0);
if (!EC_KEY_set_public_key(key,kxy)) {
EC_POINT_free(kxy);
EC_KEY_free(key);
return 0;
}
EC_POINT_free(kxy);
Anode_zero(pair,sizeof(struct AnodeECKeyPair));
Anode_memcpy((void *)&(pair->pub),(const void *)pub,sizeof(struct AnodeECKey));
Anode_memcpy((void *)&(pair->priv),(const void *)priv,sizeof(struct AnodeECKey));
pair->internal_key = key;
return 1;
}
void AnodeECKeyPair_destroy(struct AnodeECKeyPair *pair)
{
if (pair) {
if (pair->internal_key)
EC_KEY_free((EC_KEY *)pair->internal_key);
}
}
int AnodeECKeyPair_agree(const struct AnodeECKeyPair *my_key_pair,const struct AnodeECKey *their_pub_key,unsigned char *key_buf,unsigned int key_len)
{
EC_POINT *pub;
int i;
if (!AnodeEC_group) {
AnodeEC_group = EC_GROUP_new_by_curve_name(ANODE_EC_GROUP);
if (!AnodeEC_group) return 0;
}
if (!my_key_pair->internal_key)
return 0;
if (their_pub_key->bytes != ANODE_EC_PUBLIC_KEY_BYTES)
return 0;
pub = EC_POINT_new(AnodeEC_group);
if (!pub)
return 0;
EC_POINT_oct2point(AnodeEC_group,pub,their_pub_key->key,ANODE_EC_PUBLIC_KEY_BYTES,0);
i = ECDH_compute_key(key_buf,key_len,pub,(EC_KEY *)my_key_pair->internal_key,&AnodeEC_KDF);
if (i != (int)key_len) {
EC_POINT_free(pub);
return 0;
}
EC_POINT_free(pub);
return 1;
}
void AnodeEC_random(unsigned char *buf,unsigned int len)
{
RAND_pseudo_bytes(buf,len);
}

61
attic/historic/anode/libanode/impl/ec.h Normal file
View file

@ -0,0 +1,61 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* Elliptic curve glue -- hides OpenSSL code behind this source module */
#ifndef _ANODE_EC_H
#define _ANODE_EC_H
#include "misc.h"
/* Right now, only one mode is supported: NIST-P-256. This is the only mode
* supported in the spec as well, and should be good for quite some time.
* If other modes are needed this code will need to be refactored. */
/* NIST-P-256 prime size in bytes */
#define ANODE_EC_PRIME_BYTES 32
/* Sizes of key fields */
#define ANODE_EC_GROUP NID_X9_62_prime256v1
#define ANODE_EC_PUBLIC_KEY_BYTES (ANODE_EC_PRIME_BYTES + 1)
#define ANODE_EC_PRIVATE_KEY_BYTES ANODE_EC_PRIME_BYTES
/* Larger of public or private key bytes, used for buffers */
#define ANODE_EC_MAX_BYTES ANODE_EC_PUBLIC_KEY_BYTES
struct AnodeECKey
{
unsigned char key[ANODE_EC_MAX_BYTES];
unsigned int bytes;
};
struct AnodeECKeyPair
{
struct AnodeECKey pub;
struct AnodeECKey priv;
void *internal_key;
};
/* Key management functions */
int AnodeECKeyPair_generate(struct AnodeECKeyPair *pair);
int AnodeECKeyPair_init(struct AnodeECKeyPair *pair,const struct AnodeECKey *pub,const struct AnodeECKey *priv);
void AnodeECKeyPair_destroy(struct AnodeECKeyPair *pair);
int AnodeECKeyPair_agree(const struct AnodeECKeyPair *my_key_pair,const struct AnodeECKey *their_pub_key,unsigned char *key_buf,unsigned int key_len);
/* Provides access to the secure PRNG used to generate keys */
void AnodeEC_random(unsigned char *buf,unsigned int len);
#endif

118
attic/historic/anode/libanode/impl/environment.c Normal file
View file

@ -0,0 +1,118 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
#include "environment.h"
#ifdef WINDOWS
#include <windows.h>
#else
#include <sys/stat.h>
#include <string.h>
#endif
static char Anode_cache_base[1024] = { 0 };
const char *Anode_get_cache()
{
if (Anode_cache_base[0])
return Anode_cache_base;
#ifdef WINDOWS
#else
char tmp[1024];
char home[1024];
unsigned int i;
struct stat st;
const char *_home = getenv("HOME");
if (!_home)
return (const char *)0;
for(i=0;i<sizeof(home);++i) {
home[i] = _home[i];
if (!home[i]) {
if (i == 0)
return (const char *)0;
else if (home[i-1] == ANODE_PATH_SEPARATOR)
home[i-1] = (char)0;
break;
}
}
if (i == sizeof(home))
return (const char *)0;
#ifdef __APPLE__
snprintf(tmp,sizeof(tmp),"%s%cLibrary",home,ANODE_PATH_SEPARATOR);
tmp[sizeof(tmp)-1] = (char)0;
if (!stat(tmp,&st)) {
sprintf(tmp,"%s%cLibrary%cCaches",home,ANODE_PATH_SEPARATOR,ANODE_PATH_SEPARATOR);
if (stat(tmp,&st)) {
if (mkdir(tmp,0700))
return (const char *)0;
}
snprintf(Anode_cache_base,sizeof(Anode_cache_base),"%s%ccom.zerotier.anode",tmp,ANODE_PATH_SEPARATOR);
Anode_cache_base[sizeof(Anode_cache_base)-1] = (char)0;
if (stat(Anode_cache_base,&st)) {
if (mkdir(Anode_cache_base,0700)) {
Anode_cache_base[0] = (char)0;
return (const char *)0;
}
}
return Anode_cache_base;
}
#endif
snprintf(tmp,sizeof(tmp),"%s%c.anode",home,ANODE_PATH_SEPARATOR);
tmp[sizeof(tmp)-1] = (char)0;
if (stat(tmp,&st)) {
if (mkdir(tmp,0700)) {
Anode_cache_base[0] = (char)0;
return (const char *)0;
}
}
snprintf(Anode_cache_base,sizeof(Anode_cache_base),"%s%ccaches",tmp,ANODE_PATH_SEPARATOR);
Anode_cache_base[sizeof(Anode_cache_base)-1] = (char)0;
if (stat(Anode_cache_base,&st)) {
if (mkdir(Anode_cache_base,0700)) {
Anode_cache_base[0] = (char)0;
return (const char *)0;
}
}
return Anode_cache_base;
#endif
}
char *Anode_get_cache_sub(const char *cache_subdir,char *buf,unsigned int len)
{
struct stat st;
const char *cache_base = Anode_get_cache();
if (!len)
return (char *)0;
if (!cache_base)
return (char *)0;
snprintf(buf,len,"%s%c%s",cache_base,ANODE_PATH_SEPARATOR,cache_subdir);
buf[len-1] = (char)0;
if (stat(buf,&st)) {
if (mkdir(buf,0700))
return (char *)0;
}
return buf;
}

30
attic/historic/anode/libanode/impl/environment.h Normal file
View file

@ -0,0 +1,30 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef _ANODE_ENVIRONMENT_H
#define _ANODE_ENVIRONMENT_H
#ifdef WINDOWS
#define ANODE_PATH_SEPARATOR '\\'
#else
#define ANODE_PATH_SEPARATOR '/'
#endif
const char *Anode_get_cache();
char *Anode_get_cache_sub(const char *cache_subdir,char *buf,unsigned int len);
#endif

558
attic/historic/anode/libanode/impl/http_client.c Normal file
View file

@ -0,0 +1,558 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include "http_client.h"
#include "misc.h"
#include "types.h"
/* How much to increment read buffer at each capacity top? */
#define ANODE_HTTP_CAPACITY_INCREMENT 4096
static void AnodeHttpClient_close_and_fail(struct AnodeHttpClient *client)
{
if (client->impl.tcp_connection) {
client->impl.transport_engine->tcp_close(client->impl.transport_engine,client->impl.tcp_connection);
client->impl.tcp_connection = (AnodeTransportTcpConnection *)0;
}
client->response.data_length = 0;
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_CLOSED;
if (client->handler)
client->handler(client);
}
static void AnodeHttpClient_do_initiate_client(struct AnodeHttpClient *client)
{
const char *method = "";
long l,i;
switch(client->method) {
case ANODE_HTTP_GET: method = "GET"; break;
case ANODE_HTTP_HEAD: method = "HEAD"; break;
case ANODE_HTTP_POST: method = "POST"; break;
}
client->impl.outbuf_len = snprintf((char *)client->impl.outbuf,sizeof(client->impl.outbuf),
"%s %s%s%s HTTP/1.1\r\nHost: %s:%d\r\n%s",
method,
client->uri.path,
((client->uri.query[0]) ? "?" : ""),
client->uri.query,
client->uri.host,
((client->uri.port > 0) ? client->uri.port : 80),
((client->keepalive) ? "" : "Connection: close\r\n")
);
if (client->impl.outbuf_len >= (sizeof(client->impl.outbuf) - 2)) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_HEADERS_TOO_LARGE;
AnodeHttpClient_close_and_fail(client);
return;
}
if (client->method == ANODE_HTTP_POST) {
if ((client->data)&&(client->data_length)) {
client->impl.outbuf_len += snprintf((char *)client->impl.outbuf + client->impl.outbuf_len,sizeof(client->impl.outbuf) - client->impl.outbuf_len,
"Content-Type: %s\r\n",
(client->data_content_type ? client->data_content_type : "application/x-www-form-urlencoded")
);
if (client->impl.outbuf_len >= (sizeof(client->impl.outbuf) - 2)) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_HEADERS_TOO_LARGE;
AnodeHttpClient_close_and_fail(client);
return;
}
client->impl.outbuf_len += snprintf((char *)client->impl.outbuf + client->impl.outbuf_len,sizeof(client->impl.outbuf) - client->impl.outbuf_len,
"Content-Length: %u\r\n",
client->data_length
);
if (client->impl.outbuf_len >= (sizeof(client->impl.outbuf) - 2)) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_HEADERS_TOO_LARGE;
AnodeHttpClient_close_and_fail(client);
return;
}
} else {
client->impl.outbuf_len += snprintf((char *)client->impl.outbuf + client->impl.outbuf_len,sizeof(client->impl.outbuf) - client->impl.outbuf_len,
"Content-Length: 0\r\n"
);
if (client->impl.outbuf_len >= (sizeof(client->impl.outbuf) - 2)) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_HEADERS_TOO_LARGE;
AnodeHttpClient_close_and_fail(client);
return;
}
}
}
l = AnodeDictionary_write(&(client->headers),(char *)client->impl.outbuf + client->impl.outbuf_len,(long)(sizeof(client->impl.outbuf) - client->impl.outbuf_len - 2),"\r\n",": ");
if (l < 0) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_HEADERS_TOO_LARGE;
AnodeHttpClient_close_and_fail(client);
return;
}
client->impl.outbuf_len += (unsigned int)l;
if (client->impl.outbuf_len >= (sizeof(client->impl.outbuf) - 2)) { /* sanity check */
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_HEADERS_TOO_LARGE;
AnodeHttpClient_close_and_fail(client);
return;
}
client->impl.outbuf[client->impl.outbuf_len++] = '\r';
client->impl.outbuf[client->impl.outbuf_len++] = '\n';
if ((client->method == ANODE_HTTP_POST)&&(client->data)&&(client->data_length)) {
i = sizeof(client->impl.outbuf) - client->impl.outbuf_len;
if (i > client->data_length)
i = client->data_length;
Anode_memcpy((client->impl.outbuf + client->impl.outbuf_len),client->data,i);
client->impl.request_data_ptr += i;
client->impl.outbuf_len += i;
}
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_SEND;
client->impl.transport_engine->tcp_start_writing(client->impl.transport_engine,client->impl.tcp_connection);
}
static void AnodeHttpClient_tcp_outgoing_connect_handler(
AnodeTransportEngine *transport,
AnodeTransportTcpConnection *connection,
int error_code)
{
struct AnodeHttpClient *client;
if (!(client = (struct AnodeHttpClient *)(connection->ptr)))
return;
if ((client->impl.phase == ANODE_HTTP_REQUEST_PHASE_CONNECT)&&(!client->impl.freed)) {
if (error_code) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_CONNECT_FAILED;
AnodeHttpClient_close_and_fail(client);
} else {
client->impl.tcp_connection = connection;
AnodeHttpClient_do_initiate_client(client);
}
} else transport->tcp_close(transport,connection);
}
static void AnodeHttpClient_tcp_connection_terminated_handler(
AnodeTransportEngine *transport,
AnodeTransportTcpConnection *connection,
int error_code)
{
struct AnodeHttpClient *client;
if (!(client = (struct AnodeHttpClient *)(connection->ptr)))
return;
if (client->impl.freed)
return;
client->response.data_length = 0;
client->impl.tcp_connection = (AnodeTransportTcpConnection *)0;
if ((client->impl.phase != ANODE_HTTP_REQUEST_PHASE_KEEPALIVE)&&(client->impl.phase != ANODE_HTTP_REQUEST_PHASE_CLOSED)) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_SERVER_CLOSED_CONNECTION;
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_CLOSED;
AnodeHttpClient_close_and_fail(client);
} else client->impl.phase = ANODE_HTTP_REQUEST_PHASE_CLOSED;
}
static void AnodeHttpClient_tcp_receive_handler(
AnodeTransportEngine *transport,
AnodeTransportTcpConnection *connection,
void *data,
unsigned int data_length)
{
struct AnodeHttpClient *client;
char *p1,*p2;
unsigned int i;
long l;
if (!(client = (struct AnodeHttpClient *)(connection->ptr)))
return;
if (client->impl.freed) {
transport->tcp_close(transport,connection);
return;
}
if (!client->response.data)
client->response.data = malloc(client->impl.response_data_capacity = ANODE_HTTP_CAPACITY_INCREMENT);
i = 0;
while (i < data_length) {
switch(client->impl.read_mode) {
case ANODE_HTTP_READ_MODE_WAITING:
for(;i<data_length;++i) {
if (((const char *)data)[i] == '\n') {
((char *)client->response.data)[client->response.data_length] = (char)0;
client->response.data_length = 0;
p1 = (char *)Anode_strchr((char *)client->response.data,' ');
if (!p1)
p1 = (char *)Anode_strchr((char *)client->response.data,'\t');
if (p1) {
while ((*p1 == ' ')||(*p1 == '\t')) ++p1;
if (!*p1) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_INVALID_RESPONSE;
AnodeHttpClient_close_and_fail(client);
return;
}
p2 = p1 + 1;
while (*p2) {
if ((*p2 == ' ')||(*p2 == '\t')||(*p2 == '\r')||(*p2 == '\n')) {
*p2 = (char)0;
break;
} else ++p2;
}
client->response.code = (int)strtol(p1,(char **)0,10);
client->impl.read_mode = ANODE_HTTP_READ_MODE_HEADERS;
++i; break; /* Exit inner for() */
}
} else {
((char *)client->response.data)[client->response.data_length++] = ((const char *)data)[i];
if (client->response.data_length >= client->impl.response_data_capacity)
client->response.data = realloc(client->response.data,client->impl.response_data_capacity += ANODE_HTTP_CAPACITY_INCREMENT);
}
}
break;
case ANODE_HTTP_READ_MODE_HEADERS:
case ANODE_HTTP_READ_MODE_CHUNKED_FOOTER:
for(;i<data_length;++i) {
if (((const char *)data)[i] == '\n') {
client->impl.header_line_buf[client->impl.header_line_buf_ptr] = (char)0;
client->impl.header_line_buf_ptr = 0;
if ((!client->impl.header_line_buf[0])||((client->impl.header_line_buf[0] == '\r')&&(!client->impl.header_line_buf[1]))) {
/* If the line is empty (or is empty with \r\n as the
* line terminator), we're at the end. */
if (client->impl.read_mode == ANODE_HTTP_READ_MODE_CHUNKED_FOOTER) {
/* If this is a chunked footer, we finally end the
* chunked response. */
client->impl.read_mode = ANODE_HTTP_READ_MODE_WAITING;
if (client->keepalive)
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_KEEPALIVE;
else {
client->impl.transport_engine->tcp_close(client->impl.transport_engine,client->impl.tcp_connection);
client->impl.tcp_connection = (AnodeTransportTcpConnection *)0;
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_CLOSED;
}
if (client->handler)
client->handler(client);
if (client->impl.freed)
return;
} else {
/* Otherwise, this is a regular header block */
if (client->response.code == 100) {
/* Ignore 100 Continue messages */
client->impl.read_mode = ANODE_HTTP_READ_MODE_WAITING;
++i; break; /* Exit inner for() */
} else if ((client->response.code == 200)&&(client->method != ANODE_HTTP_HEAD)) {
/* Other messages get their headers parsed to determine
* how to read them. */
p1 = (char *)AnodeDictionary_get(&(client->response.headers),"transfer-encoding");
if ((p1)&&(Anode_strcaseeq(p1,"chunked"))) {
/* Chunked encoding enters chunked mode */
client->impl.header_line_buf_ptr = 0;
client->impl.read_mode = ANODE_HTTP_READ_MODE_CHUNKED_CHUNK_SIZE;
++i; break; /* Exit inner for() */
} else {
/* Else we must have a Content-Length header */
p1 = (char *)AnodeDictionary_get(&(client->response.headers),"content-length");
if (!p1) {
/* No chunked or content length is not supported */
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_INVALID_RESPONSE;
AnodeHttpClient_close_and_fail(client);
return;
} else {
/* Enter block read mode with content length */
l = strtol(p1,(char **)0,10);
if (l <= 0) {
/* Zero length data is all done... */
client->impl.expecting_response_length = 0;
client->impl.read_mode = ANODE_HTTP_READ_MODE_WAITING;
if (client->keepalive)
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_KEEPALIVE;
else {
client->impl.transport_engine->tcp_close(client->impl.transport_engine,client->impl.tcp_connection);
client->impl.tcp_connection = (AnodeTransportTcpConnection *)0;
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_CLOSED;
}
if (client->handler)
client->handler(client);
if (client->impl.freed)
return;
++i; break; /* Exit inner for() */
} else {
/* Else start reading... */
client->impl.expecting_response_length = (unsigned int)l;
client->impl.read_mode = ANODE_HTTP_READ_MODE_BLOCK;
++i; break; /* Exit inner for() */
}
}
}
} else {
/* HEAD clients or non-200 codes get headers only */
client->impl.expecting_response_length = 0;
client->impl.read_mode = ANODE_HTTP_READ_MODE_WAITING;
if (client->keepalive)
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_KEEPALIVE;
else {
client->impl.transport_engine->tcp_close(client->impl.transport_engine,client->impl.tcp_connection);
client->impl.tcp_connection = (AnodeTransportTcpConnection *)0;
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_CLOSED;
}
if (client->handler)
client->handler(client);
if (client->impl.freed)
return;
++i; break; /* Exit inner for() */
}
}
} else {
/* Otherwise this is another header, add to dictionary */
AnodeDictionary_read(
&(client->response.headers),
client->impl.header_line_buf,
"\r\n",
": \t",
"",
(char)0,
1,
1
);
}
} else {
client->impl.header_line_buf[client->impl.header_line_buf_ptr++] = ((const char *)data)[i];
if (client->impl.header_line_buf_ptr >= sizeof(client->impl.header_line_buf)) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_INVALID_RESPONSE;
AnodeHttpClient_close_and_fail(client);
return;
}
}
}
break;
case ANODE_HTTP_READ_MODE_BLOCK:
if ((client->response.data_length + client->impl.expecting_response_length) > client->impl.response_data_capacity)
client->response.data = realloc(client->response.data,client->impl.response_data_capacity = (client->response.data_length + client->impl.expecting_response_length));
for(;((i<data_length)&&(client->impl.expecting_response_length));++i) {
((char *)client->response.data)[client->response.data_length++] = ((const char *)data)[i];
--client->impl.expecting_response_length;
}
if (!client->impl.expecting_response_length) {
client->impl.read_mode = ANODE_HTTP_READ_MODE_WAITING;
if (client->keepalive)
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_KEEPALIVE;
else {
client->impl.transport_engine->tcp_close(client->impl.transport_engine,client->impl.tcp_connection);
client->impl.tcp_connection = (AnodeTransportTcpConnection *)0;
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_CLOSED;
}
if (client->handler)
client->handler(client);
if (client->impl.freed)
return;
}
break;
case ANODE_HTTP_READ_MODE_CHUNKED_CHUNK_SIZE:
for(;i<data_length;++i) {
if (((const char *)data)[i] == '\n') {
client->impl.header_line_buf[client->impl.header_line_buf_ptr] = (char)0;
client->impl.header_line_buf_ptr = 0;
p1 = client->impl.header_line_buf;
while (*p1) {
if ((*p1 == ';')||(*p1 == ' ')||(*p1 == '\r')||(*p1 == '\n')||(*p1 == '\t')) {
*p1 = (char)0;
break;
} else ++p1;
}
if (client->impl.header_line_buf[0]) {
l = strtol(client->impl.header_line_buf,(char **)0,16);
if (l <= 0) {
/* Zero length ends chunked and enters footer mode */
client->impl.expecting_response_length = 0;
client->impl.read_mode = ANODE_HTTP_READ_MODE_CHUNKED_FOOTER;
} else {
/* Otherwise the next chunk is to be read */
client->impl.expecting_response_length = (unsigned int)l;
client->impl.read_mode = ANODE_HTTP_READ_MODE_CHUNKED_DATA;
}
++i; break; /* Exit inner for() */
}
} else {
client->impl.header_line_buf[client->impl.header_line_buf_ptr++] = ((const char *)data)[i];
if (client->impl.header_line_buf_ptr >= sizeof(client->impl.header_line_buf)) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_INVALID_RESPONSE;
AnodeHttpClient_close_and_fail(client);
return;
}
}
}
break;
case ANODE_HTTP_READ_MODE_CHUNKED_DATA:
if ((client->response.data_length + client->impl.expecting_response_length) > client->impl.response_data_capacity)
client->response.data = realloc(client->response.data,client->impl.response_data_capacity = (client->response.data_length + client->impl.expecting_response_length));
for(;((i<data_length)&&(client->impl.expecting_response_length));++i) {
((char *)client->response.data)[client->response.data_length++] = ((const char *)data)[i];
--client->impl.expecting_response_length;
}
if (!client->impl.expecting_response_length)
client->impl.read_mode = ANODE_HTTP_READ_MODE_CHUNKED_CHUNK_SIZE;
break;
}
}
}
static void AnodeHttpClient_tcp_available_for_write_handler(
AnodeTransportEngine *transport,
AnodeTransportTcpConnection *connection)
{
struct AnodeHttpClient *client;
unsigned int i,j;
int n;
if (!(client = (struct AnodeHttpClient *)(connection->ptr)))
return;
if (client->impl.freed) {
transport->tcp_close(transport,connection);
return;
}
if (client->impl.phase == ANODE_HTTP_REQUEST_PHASE_SEND) {
n = client->impl.transport_engine->tcp_send(client->impl.transport_engine,client->impl.tcp_connection,(const void *)client->impl.outbuf,(int)client->impl.outbuf_len);
if (n < 0) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_SERVER_CLOSED_CONNECTION;
AnodeHttpClient_close_and_fail(client);
} else if (n > 0) {
for(i=0,j=(client->impl.outbuf_len - (unsigned int)n);i<j;++i)
client->impl.outbuf[i] = client->impl.outbuf[i + (unsigned int)n];
client->impl.outbuf_len -= (unsigned int)n;
if ((client->method == ANODE_HTTP_POST)&&(client->data)&&(client->data_length)) {
i = sizeof(client->impl.outbuf) - client->impl.outbuf_len;
j = client->data_length - client->impl.request_data_ptr;
if (i > j)
i = j;
Anode_memcpy((client->impl.outbuf + client->impl.outbuf_len),client->data,i);
client->impl.request_data_ptr += i;
client->impl.outbuf_len += i;
}
if (!client->impl.outbuf_len) {
client->impl.transport_engine->tcp_stop_writing(client->impl.transport_engine,client->impl.tcp_connection);
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_RECEIVE;
}
}
} else client->impl.transport_engine->tcp_stop_writing(client->impl.transport_engine,client->impl.tcp_connection);
}
static void AnodeHttpClient_dns_result_handler(
AnodeTransportEngine *transport,
void *ptr,
int error_code,
const char *name,
const AnodeTransportIpAddress *ip_addresses,
unsigned int ip_address_count,
const AnodeAddress *anode_address)
{
struct AnodeHttpClient *client;
AnodeTransportIpEndpoint to_endpoint;
if (!(client = (struct AnodeHttpClient *)ptr))
return;
if (client->impl.freed)
return;
if ((error_code)||(!ip_address_count)) {
if (client->impl.phase == ANODE_HTTP_REQUEST_PHASE_RESOLVE) {
client->response.code = ANODE_HTTP_SPECIAL_RESPONSE_DNS_RESOLVE_FAILED;
AnodeHttpClient_close_and_fail(client);
}
} else {
client->impl.phase = ANODE_HTTP_REQUEST_PHASE_CONNECT;
Anode_memcpy(&to_endpoint.address,ip_addresses,sizeof(AnodeTransportIpAddress));
to_endpoint.port = (client->uri.port > 0) ? client->uri.port : 80;
client->impl.transport_engine->tcp_connect(
client->impl.transport_engine,
client,
&AnodeHttpClient_tcp_outgoing_connect_handler,
&AnodeHttpClient_tcp_connection_terminated_handler,
&AnodeHttpClient_tcp_receive_handler,
&AnodeHttpClient_tcp_available_for_write_handler,
&to_endpoint);
}
}
struct AnodeHttpClient *AnodeHttpClient_new(AnodeTransportEngine *transport_engine)
{
struct AnodeHttpClient *req = malloc(sizeof(struct AnodeHttpClient));
Anode_zero(req,sizeof(struct AnodeHttpClient));
AnodeDictionary_init(&(req->headers),0);
AnodeDictionary_init(&(req->response.headers),0);
req->impl.transport_engine = transport_engine;
return req;
}
void AnodeHttpClient_send(struct AnodeHttpClient *client)
{
client->response.code = 0;
client->response.data_length = 0;
AnodeDictionary_clear(&(client->response.headers));
client->impl.request_data_ptr = 0;
client->impl.expecting_response_length = 0;
client->impl.read_mode = ANODE_HTTP_READ_MODE_WAITING;
client->impl.outbuf_len = 0;
if (!client->impl.tcp_connection) {
client->impl.transport_engine->dns_resolve(
client->impl.transport_engine,
&AnodeHttpClient_dns_result_handler,
client,
client->uri.host,
ANODE_TRANSPORT_DNS_QUERY_ALWAYS,
ANODE_TRANSPORT_DNS_QUERY_IF_NO_PREVIOUS,
ANODE_TRANSPORT_DNS_QUERY_NEVER);
} else AnodeHttpClient_do_initiate_client(client);
}
void AnodeHttpClient_free(struct AnodeHttpClient *client)
{
AnodeDictionary_destroy(&(client->headers));
AnodeDictionary_destroy(&(client->response.headers));
if (client->impl.tcp_connection) {
client->impl.transport_engine->tcp_close(client->impl.transport_engine,client->impl.tcp_connection);
client->impl.tcp_connection = (AnodeTransportTcpConnection *)0;
}
if (client->response.data)
free(client->response.data);
client->impl.freed = 1;
client->impl.transport_engine->run_later(client->impl.transport_engine,client,&free);
}

200
attic/historic/anode/libanode/impl/http_client.h Normal file
View file

@ -0,0 +1,200 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef _ANODE_HTTP_CLIENT_H
#define _ANODE_HTTP_CLIENT_H
#include <stdio.h>
#include <stdlib.h>
#include "dictionary.h"
#include "../anode.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* HTTP request type
*/
enum AnodeHttpClientRequestMethod
{
ANODE_HTTP_GET = 0,
ANODE_HTTP_HEAD = 1,
ANODE_HTTP_POST = 2
};
/*
* Special response codes to indicate I/O errors
*/
#define ANODE_HTTP_SPECIAL_RESPONSE_DNS_RESOLVE_FAILED -1
#define ANODE_HTTP_SPECIAL_RESPONSE_CONNECT_FAILED -2
#define ANODE_HTTP_SPECIAL_RESPONSE_HEADERS_TOO_LARGE -3
#define ANODE_HTTP_SPECIAL_RESPONSE_SERVER_CLOSED_CONNECTION -4
#define ANODE_HTTP_SPECIAL_RESPONSE_INVALID_RESPONSE -5
/**
* Simple HTTP client
*/
struct AnodeHttpClient
{
/**
* Request URI
*/
AnodeURI uri;
/**
* Request method: GET, PUT, HEAD, or POST
*/
enum AnodeHttpClientRequestMethod method;
/**
* Data for POST requests
*
* It is your responsibility to manage and/or free this pointer. The HTTP
* client only reads from it.
*/
const void *data;
unsigned int data_length;
/**
* Content type for data, or null for application/x-www-form-urlencoded
*/
const char *data_content_type;
/**
* Set to non-zero to use HTTP connection keepalive
*
* If keepalive is enabled, this request can be modified and re-used and
* its associated connection will stay open (being reopened if needed)
* until it is freed.
*
* Note that this client is too dumb to pool connections and pick them on
* the basis of host. Keepalive mode should only be set if the next request
* will be from the same host and port, otherwise you will get a '404'.
*/
int keepalive;
/**
* Function pointer to be called when request is complete (or fails)
*/
void (*handler)(struct AnodeHttpClient *);
/**
* Two arbitrary pointers that can be stored here for use by the handler.
* These are not accessed or modified by the client.
*/
void *ptr[2];
/**
* Request headers
*/
struct AnodeDictionary headers;
struct {
/**
* Response code, set on completion or failure before handler is called
*
* Also check for the special response codes defined in http_client.h as
* these negative codes indicate network or other errors.
*/
int code;
/**
* Response data, for GET and POST requests
*/
void *data;
/**
* Length of response data
*/
unsigned int data_length;
/**
* Response headers
*/
struct AnodeDictionary headers;
} response;
/**
* Internal fields used by implementation
*/
struct {
/* Transport engine being used by request */
AnodeTransportEngine *transport_engine;
/* Connection to which request has been sent, or null if none */
struct AnodeHttpConnection *connection;
/* Buffer for reading chunked mode chunk lines (can't use data buf) */
char header_line_buf[256];
unsigned int header_line_buf_ptr;
/* Where are we in sending request data? */
unsigned int request_data_ptr;
/* Capacity of response_data buffer */
unsigned int response_data_capacity;
/* How much response data are we currently expecting? */
/* This is content-length in block mode or chunk length in chunked mode */
unsigned int expecting_response_length;
/* Read mode */
enum {
ANODE_HTTP_READ_MODE_WAITING = 0,
ANODE_HTTP_READ_MODE_HEADERS = 1,
ANODE_HTTP_READ_MODE_BLOCK = 2,
ANODE_HTTP_READ_MODE_CHUNKED_CHUNK_SIZE = 3,
ANODE_HTTP_READ_MODE_CHUNKED_DATA = 4,
ANODE_HTTP_READ_MODE_CHUNKED_FOOTER = 5
} read_mode;
/* Connection from transport engine */
AnodeTransportTcpConnection *tcp_connection;
/* Write buffer */
unsigned char outbuf[16384];
unsigned int outbuf_len;
/* Phase of request state machine */
enum {
ANODE_HTTP_REQUEST_PHASE_RESOLVE = 0,
ANODE_HTTP_REQUEST_PHASE_CONNECT = 1,
ANODE_HTTP_REQUEST_PHASE_SEND = 2,
ANODE_HTTP_REQUEST_PHASE_RECEIVE = 3,
ANODE_HTTP_REQUEST_PHASE_KEEPALIVE = 4,
ANODE_HTTP_REQUEST_PHASE_CLOSED = 5
} phase;
/* Has request object been freed? */
int freed;
/**
* Pointer used internally for putting requests into linked lists
*/
struct AnodeHttpClient *next;
} impl;
};
struct AnodeHttpClient *AnodeHttpClient_new(AnodeTransportEngine *transport_engine);
void AnodeHttpClient_send(struct AnodeHttpClient *client);
void AnodeHttpClient_free(struct AnodeHttpClient *client);
#ifdef __cplusplus
}
#endif
#endif

190
attic/historic/anode/libanode/impl/misc.c Normal file
View file

@ -0,0 +1,190 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "misc.h"
#include "types.h"
static const char Anode_hex_chars[16] = {
'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'
};
static const char Anode_base32_chars[32] = {
'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
'r','s','t','u','v','w','x','y','z','2','3','4','5','6','7'
};
static const unsigned char Anode_base32_bits[256] = {
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,26,27,28,29,30,31,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,
6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,0,0,0,0,0,0,0,1,2,
3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
};
/* Table for converting ASCII chars to lower case */
const unsigned char Anode_ascii_tolower_table[256] = {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};
void Anode_trim(char *s)
{
char *dest = s;
char *last;
while ((*s)&&((*s == ' ')||(*s == '\t')||(*s == '\r')||(*s == '\n')))
++s;
last = s;
while ((*dest = *s)) {
if ((*dest != ' ')&&(*dest != '\t')&&(*dest != '\r')&&(*dest != '\n'))
last = dest;
++dest;
++s;
}
if (*last)
*(++last) = (char)0;
}
unsigned int Anode_rand()
{
static volatile int need_seed = 1;
if (need_seed) {
need_seed = 0;
srandom((unsigned long)Anode_time64());
}
return (unsigned int)random();
}
void Anode_to_hex(const unsigned char *b,unsigned int len,char *h,unsigned int hlen)
{
unsigned int i;
if ((len * 2) >= hlen)
len = (hlen - 1) / 2;
for(i=0;i<len;++i) {
*(h++) = Anode_hex_chars[b[i] >> 4];
*(h++) = Anode_hex_chars[b[i] & 0xf];
}
*h = (char)0;
}
void Anode_from_hex(const char *h,unsigned char *b,unsigned int blen)
{
unsigned char *end = b + blen;
unsigned char v = (unsigned char)0;
while (b != end) {
switch(*(h++)) {
case '0': v = 0x00; break;
case '1': v = 0x10; break;
case '2': v = 0x20; break;
case '3': v = 0x30; break;
case '4': v = 0x40; break;
case '5': v = 0x50; break;
case '6': v = 0x60; break;
case '7': v = 0x70; break;
case '8': v = 0x80; break;
case '9': v = 0x90; break;
case 'a': v = 0xa0; break;
case 'b': v = 0xb0; break;
case 'c': v = 0xc0; break;
case 'd': v = 0xd0; break;
case 'e': v = 0xe0; break;
case 'f': v = 0xf0; break;
default: return;
}
switch(*(h++)) {
case '0': v |= 0x00; break;
case '1': v |= 0x01; break;
case '2': v |= 0x02; break;
case '3': v |= 0x03; break;
case '4': v |= 0x04; break;
case '5': v |= 0x05; break;
case '6': v |= 0x06; break;
case '7': v |= 0x07; break;
case '8': v |= 0x08; break;
case '9': v |= 0x09; break;
case 'a': v |= 0x0a; break;
case 'b': v |= 0x0b; break;
case 'c': v |= 0x0c; break;
case 'd': v |= 0x0d; break;
case 'e': v |= 0x0e; break;
case 'f': v |= 0x0f; break;
default: return;
}
*(b++) = v;
}
}
void Anode_base32_5_to_8(const unsigned char *in,char *out)
{
out[0] = Anode_base32_chars[(in[0]) >> 3];
out[1] = Anode_base32_chars[(in[0] & 0x07) << 2 | (in[1] & 0xc0) >> 6];
out[2] = Anode_base32_chars[(in[1] & 0x3e) >> 1];
out[3] = Anode_base32_chars[(in[1] & 0x01) << 4 | (in[2] & 0xf0) >> 4];
out[4] = Anode_base32_chars[(in[2] & 0x0f) << 1 | (in[3] & 0x80) >> 7];
out[5] = Anode_base32_chars[(in[3] & 0x7c) >> 2];
out[6] = Anode_base32_chars[(in[3] & 0x03) << 3 | (in[4] & 0xe0) >> 5];
out[7] = Anode_base32_chars[(in[4] & 0x1f)];
}
void Anode_base32_8_to_5(const char *in,unsigned char *out)
{
out[0] = ((Anode_base32_bits[(unsigned int)in[0]]) << 3) | (Anode_base32_bits[(unsigned int)in[1]] & 0x1C) >> 2;
out[1] = ((Anode_base32_bits[(unsigned int)in[1]] & 0x03) << 6) | (Anode_base32_bits[(unsigned int)in[2]]) << 1 | (Anode_base32_bits[(unsigned int)in[3]] & 0x10) >> 4;
out[2] = ((Anode_base32_bits[(unsigned int)in[3]] & 0x0F) << 4) | (Anode_base32_bits[(unsigned int)in[4]] & 0x1E) >> 1;
out[3] = ((Anode_base32_bits[(unsigned int)in[4]] & 0x01) << 7) | (Anode_base32_bits[(unsigned int)in[5]]) << 2 | (Anode_base32_bits[(unsigned int)in[6]] & 0x18) >> 3;
out[4] = ((Anode_base32_bits[(unsigned int)in[6]] & 0x07) << 5) | (Anode_base32_bits[(unsigned int)in[7]]);
}

193
attic/historic/anode/libanode/impl/misc.h Normal file
View file

@ -0,0 +1,193 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* This contains miscellaneous functions, including some re-implementations
* of some functions from string.h. This is to help us port to some platforms
* (cough Windows Mobile cough) that lack a lot of the basic C library. */
#ifndef _ANODE_MISC_H
#define _ANODE_MISC_H
#include <time.h>
#include <sys/time.h>
#include "types.h"
#ifndef ANODE_NO_STRING_H
#include <string.h>
#include <stdlib.h>
#endif
/* Table mapping ASCII characters to themselves or their lower case */
extern const unsigned char Anode_ascii_tolower_table[256];
/* Get the lower case version of an ASCII char */
#define Anode_tolower(c) ((char)Anode_ascii_tolower_table[((unsigned long)((unsigned char)(c)))])
/* Test strings for equality, return nonzero if equal */
static inline unsigned int Anode_streq(const char *restrict a,const char *restrict b)
{
if ((!a)||(!b))
return 0;
while (*a == *(b++)) {
if (!*(a++))
return 1;
}
return 0;
}
/* Equality test ignoring (ASCII) case */
static inline unsigned int Anode_strcaseeq(const char *restrict a,const char *restrict b)
{
if ((!a)||(!b))
return 0;
while (Anode_tolower(*a) == Anode_tolower(*(b++))) {
if (!*(a++))
return 1;
}
return 0;
}
/* Safe c-string copy, ensuring that dest[] always ends with zero */
static inline void Anode_str_copy(char *restrict dest,const char *restrict src,unsigned int dest_size)
{
char *restrict dest_end = dest + (dest_size - 1);
while ((*src)&&(dest != dest_end))
*(dest++) = *(src++);
*dest = (char)0;
}
/* Simple memcpy() */
#ifdef ANODE_NO_STRING_H
static inline void Anode_memcpy(void *restrict dest,const void *restrict src,unsigned int len)
{
unsigned int i;
for(i=0;i<len;++i)
((unsigned char *restrict)dest)[i] = ((const unsigned char *restrict)src)[i];
}
#else
#define Anode_memcpy(d,s,l) memcpy((d),(s),(l))
#endif
/* Memory test for equality */
#ifdef ANODE_NO_STRING_H
static inline unsigned int Anode_mem_eq(const void *restrict a,const void *restrict b,unsigned int len)
{
unsigned int i;
for(i=0;i<len;++i) {
if (((const unsigned char *restrict)a)[i] != ((const unsigned char *restrict)b)[i])
return 0;
}
return 1;
}
#else
#define Anode_mem_eq(a,b,l) (!memcmp((a),(b),(l)))
#endif
/* Zero memory */
#ifdef ANODE_NO_STRING_H
static inline void Anode_zero(void *restrict ptr,unsigned int len)
{
unsigned int i;
for(i=0;i<len;++i)
((unsigned char *restrict)ptr)[i] = (unsigned char)0;
}
#else
#define Anode_zero(p,l) memset((p),0,(l))
#endif
/* Get a pointer to the first occurrance of a character in a string */
#ifdef ANODE_NO_STRING_H
static inline const char *Anode_strchr(const char *s,char c)
{
while (*s) {
if (*s == c)
return s;
++s;
}
return (char *)0;
}
#else
#define Anode_strchr(s,c) strchr((s),(c))
#endif
static inline unsigned int Anode_count_char(const char *s,char c)
{
unsigned int cnt = 0;
while (s) {
if (*s == c)
++cnt;
++s;
}
return cnt;
}
/* Strip all of a given set of characters from a string */
static inline void Anode_strip_all(char *s,const char *restrict schars)
{
char *d = s;
while (*s) {
if (!Anode_strchr(schars,*s))
*(d++) = *s;
++s;
}
*d = (char)0;
}
/* Trim whitespace from beginning and end of string */
void Anode_trim(char *s);
/* Get the length of a string */
#ifdef ANODE_NO_STRING_H
static inline unsigned int Anode_strlen(const char *s)
{
const char *ptr = s;
while (*ptr) ++ptr;
return (unsigned int)(ptr - s);
}
#else
#define Anode_strlen(s) strlen((s))
#endif
/* Returns number of milliseconds since the epoch (Java-style) */
static inline uint64_t Anode_time64()
{
struct timeval tv;
gettimeofday(&tv,(void *)0);
return ( (((uint64_t)tv.tv_sec) / 1000ULL) + ((uint64_t)(tv.tv_usec / 1000ULL)) );
}
/* Returns number of seconds since the epoch (*nix style) */
static inline unsigned long Anode_time()
{
struct timeval tv;
gettimeofday(&tv,(void *)0);
return (unsigned long)tv.tv_sec;
}
/* Simple random function, not cryptographically safe */
unsigned int Anode_rand();
/* Fast hex/ascii conversion */
void Anode_to_hex(const unsigned char *b,unsigned int len,char *h,unsigned int hlen);
void Anode_from_hex(const char *h,unsigned char *b,unsigned int blen);
/* Convert back and forth from base32 encoding */
/* 5 bytes -> 8 base32 characters and vice versa */
void Anode_base32_5_to_8(const unsigned char *in,char *out);
void Anode_base32_8_to_5(const char *in,unsigned char *out);
#endif

34
attic/historic/anode/libanode/impl/mutex.h Normal file
View file

@ -0,0 +1,34 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef _ANODE_MUTEX_H
#define _ANODE_MUTEX_H
#ifdef WINDOWS
#else /* WINDOWS */
#include <pthread.h>
#define AnodeMutex pthread_mutex_t
#define AnodeMutex_init(m) pthread_mutex_init((m),(const pthread_mutexattr_t *)0)
#define AnodeMutex_destroy(m) pthread_mutex_destroy((m))
#define AnodeMutex_lock(m) pthread_mutex_lock((m))
#define AnodeMutex_unlock(m) pthread_mutex_unlock((m))
#endif /* WINDOWS */
#endif

58
attic/historic/anode/libanode/impl/thread.c Normal file
View file

@ -0,0 +1,58 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "thread.h"
#include <stdlib.h>
#ifdef WINDOWS
#else /* not WINDOWS */
struct _AnodeThread
{
void (*func)(void *);
void *arg;
int wait_for_join;
pthread_t thread;
};
static void *_AnodeThread_main(void *arg)
{
((struct _AnodeThread *)arg)->func(((struct _AnodeThread *)arg)->arg);
if (!((struct _AnodeThread *)arg)->wait_for_join)
free(arg);
return (void *)0;
}
AnodeThread *AnodeThread_create(void (*func)(void *),void *arg,int wait_for_join)
{
struct _AnodeThread *t = malloc(sizeof(struct _AnodeThread));
t->func = func;
t->arg = arg;
t->wait_for_join = wait_for_join;
pthread_create(&t->thread,(const pthread_attr_t *)0,&_AnodeThread_main,(void *)t);
if (!wait_for_join)
pthread_detach(t->thread);
return (AnodeThread *)t;
}
void AnodeThread_join(AnodeThread *thread)
{
pthread_join(((struct _AnodeThread *)thread)->thread,(void **)0);
free((void *)thread);
}
#endif /* WINDOWS / not WINDOWS */

65
attic/historic/anode/libanode/impl/thread.h Normal file
View file

@ -0,0 +1,65 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef _ANODE_THREAD_H
#define _ANODE_THREAD_H
#ifdef WINDOWS
#include <windows.h>
#include <thread.h>
typedef DWORD AnodeThreadId;
#else /* not WINDOWS */
#include <pthread.h>
typedef pthread_t AnodeThreadId;
#define AnodeThread_self() pthread_self()
#define AnodeThreadId_equal(a,b) pthread_equal((pthread_t)(a),(pthread_t)(b))
#endif
typedef void AnodeThread;
/**
* Create and launch a new thread
*
* If wait_for_join is true (nonzero), the thread can and must be joined. The
* thread object won't be freed until join is called and returns. If
* wait_for_join is false, the thread object frees itself automatically on
* termination.
*
* If wait_for_join is false (zero), there is really no need to keep track of
* the thread object.
*
* @param func Function to call as thread main
* @param arg Argument to pass to function
* @param wait_for_join If false, thread deletes itself when it terminates
*/
AnodeThread *AnodeThread_create(void (*func)(void *),void *arg,int wait_for_join);
/**
* Wait for a thread to terminate and delete thread object
*
* This can only be used for threads created with wait_for_join set to true.
* The thread object is no longer valid after this call.
*
* @param thread Thread to wait for termination and delete
*/
void AnodeThread_join(AnodeThread *thread);
#endif

25
attic/historic/anode/libanode/impl/types.h Normal file
View file

@ -0,0 +1,25 @@
/* libanode: the Anode C reference implementation
* Copyright (C) 2009-2010 Adam Ierymenko <adam.ierymenko@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef _ANODE_TYPES_H
#define _ANODE_TYPES_H
#ifdef WINDOWS
#else
#include <stdint.h>
#endif
#endif