//override
void AmigaPlayer_set_volume(struct AmigaPlayer* self, Number value) {
PFUNC();
if (value < 0.0) value = 0.0;
else if (value > 1.0) value = 1.0;
self->amiga->master = value * 0.00390625;
}
void CoreMixer_ctor(struct CoreMixer* self) {
CLASS_CTOR_DEF(CoreMixer);
/* original constructor code goes here */
PFUNC();
CoreMixer_set_bufferSize(self, COREMIXER_MAX_BUFFER);
//self->bufferSize = 8192;
//vtable
self->fast = CoreMixer_fast;
self->accurate = CoreMixer_accurate;
}
//override
void AmigaPlayer_set_stereo(struct AmigaPlayer* self, Number value) {
PFUNC();
struct AmigaChannel *chan = &self->amiga->channels[0];
if (value < 0.0) value = 0.0;
else if (value > 1.0) value = 1.0;
while (chan) {
chan->level = value * chan->panning;
chan = chan->next;
}
}
//override
void Soundblaster_initialize(struct Soundblaster* self) {
PFUNC();
struct SBChannel *chan = &self->channels[0];
//super->initialize();
//CoreMixer_initialize(&self->super);
while (chan) {
//chan->initialize();
SBChannel_initialize(chan);
chan = chan->next;
}
}
//override
void AmigaPlayer_set_ntsc(struct AmigaPlayer* self, int value) {
PFUNC();
self->standard = value;
if (value) {
self->amiga->clock = 81.1688208;
self->amiga->super.samplesTick = 735;
} else {
self->amiga->clock = 80.4284580;
self->amiga->super.samplesTick = 882;
}
}
void Soundblaster_ctor(struct Soundblaster* self) {
CLASS_CTOR_DEF(Soundblaster);
// original constructor code goes here
PFUNC();
//super();
CoreMixer_ctor(&self->super);
self->super.type = CM_SOUNDBLASTER;
//vtable
self->super.fast = Soundblaster_fast;
self->super.accurate = Soundblaster_accurate;
}
//js function reset
void CoreMixer_initialize(struct CoreMixer* self) {
PFUNC();
struct Sample* sample = &self->buffer[0];
self->samplesLeft = 0;
self->remains = 0;
self->completed = 0;
while (sample) {
sample->l = sample->r = 0.0;
sample = sample->next;
}
}
void CoreMixer_set_bufferSize(struct CoreMixer* self, int value) {
PFUNC();
int i = 0; int len = 0;
//if (value == len || value < 2048) return;
assert_op(value, <=, COREMIXER_MAX_BUFFER);
len = self->vector_count_buffer;
self->vector_count_buffer = value;
if (value > len) {
Sample_ctor(&self->buffer[len]);
for(i = ++len; i < value; i++) {
Sample_ctor(&self->buffer[i]);
self->buffer[i - 1].next = &self->buffer[i];
}
}
}
/* getservbyname on mac is using thread local storage, so we dont need mutex
TODO: check if the same applies to OpenBSD */
static int getservbyname_r(const char* name, const char* proto, struct servent* result_buf,
char* buf, size_t buflen, struct servent** result) {
PFUNC();
struct servent *res;
int ret;
(void) buf; (void) buflen;
res = getservbyname(name, proto);
if(res) {
*result_buf = *res;
*result = result_buf;
ret = 0;
} else {
*result = NULL;
ret = ENOENT;
}
return ret;
}
struct hostent *proxy_gethostbyname(const char *name, struct gethostbyname_data* data) {
PFUNC();
char buff[256];
data->resolved_addr_p[0] = (char *) &data->resolved_addr;
data->resolved_addr_p[1] = NULL;
data->hostent_space.h_addr_list = data->resolved_addr_p;
// let aliases point to the NULL member, mimicking an empty list.
data->hostent_space.h_aliases = &data->resolved_addr_p[1];
data->resolved_addr = 0;
data->hostent_space.h_addrtype = AF_INET;
data->hostent_space.h_length = sizeof(in_addr_t);
gethostname(buff, sizeof(buff));
if(!strcmp(buff, name)) {
data->resolved_addr = inet_addr(buff);
if(data->resolved_addr == (in_addr_t) (-1))
data->resolved_addr = (in_addr_t) (ip_type_localhost.as_int);
goto retname;
}
// this iterates over the "known hosts" db, usually /etc/hosts
ip_type hdb_res = hostsreader_get_numeric_ip_for_name(name);
if(hdb_res.as_int != ip_type_invalid.as_int) {
data->resolved_addr = hdb_res.as_int;
goto retname;
}
data->resolved_addr = at_get_ip_for_host((char*) name, strlen(name)).as_int;
if(data->resolved_addr == (in_addr_t) ip_type_invalid.as_int) return NULL;
retname:
gethostbyname_data_setstring(data, (char*) name);
PDEBUG("return hostent space\n");
return &data->hostent_space;
}
void AmigaPlayer_ctor(struct AmigaPlayer* self, struct Amiga* amiga) {
CLASS_CTOR_DEF(AmigaPlayer);
PFUNC();
// original constructor code goes here
self->amiga = amiga ? amiga : Amiga_new();
//super(self->amiga);
CorePlayer_ctor(&self->super, (struct CoreMixer*) self->amiga);
self->super.channels = 4;
self->super.endian = BAE_BIG;
AmigaPlayer_set_ntsc(self, 0);
self->super.speed = 6;
self->super.tempo = 125;
//add vtable
self->super.set_ntsc = (void*) AmigaPlayer_set_ntsc;
self->super.set_stereo = (void*) AmigaPlayer_set_stereo;
self->super.set_volume = (void*) AmigaPlayer_set_volume;
self->super.toggle = (void*) AmigaPlayer_toggle;
}
static int timed_connect(int sock, const struct sockaddr *addr, socklen_t len) {
int ret, value;
socklen_t value_len;
struct pollfd pfd[1];
PFUNC();
pfd[0].fd = sock;
pfd[0].events = POLLOUT;
fcntl(sock, F_SETFL, O_NONBLOCK);
ret = true_connect(sock, addr, len);
PDEBUG("\nconnect ret=%d\n", ret);
if(ret == -1 && errno == EINPROGRESS) {
ret = poll_retry(pfd, 1, tcp_connect_time_out);
PDEBUG("\npoll ret=%d\n", ret);
if(ret == 1) {
value_len = sizeof(socklen_t);
getsockopt(sock, SOL_SOCKET, SO_ERROR, &value, &value_len);
PDEBUG("\nvalue=%d\n", value);
if(!value)
ret = 0;
else
ret = -1;
} else {
ret = -1;
}
} else {
#ifdef DEBUG
if(ret == -1)
perror("true_connect");
#endif
if(ret != 0)
ret = -1;
}
fcntl(sock, F_SETFL, !O_NONBLOCK);
return ret;
}
static int chain_step(int ns, proxy_data * pfrom, proxy_data * pto) {
int retcode = -1;
char *hostname;
char hostname_buf[MSG_LEN_MAX];
char ip_buf[16];
PFUNC();
if(pto->ip.octet[0] == remote_dns_subnet) {
if(!at_get_host_for_ip(pto->ip, hostname_buf)) goto usenumericip;
else hostname = hostname_buf;
} else {
usenumericip:
pc_stringfromipv4(&pto->ip.octet[0], ip_buf);
hostname = ip_buf;
}
proxychains_write_log(TP " %s:%d ", hostname, htons(pto->port));
retcode = tunnel_to(ns, pto->ip, pto->port, pfrom->pt, pfrom->user, pfrom->pass);
switch (retcode) {
case SUCCESS:
pto->ps = BUSY_STATE;
break;
case BLOCKED:
pto->ps = BLOCKED_STATE;
proxychains_write_log("<--denied\n");
close(ns);
break;
case SOCKET_ERROR:
pto->ps = DOWN_STATE;
proxychains_write_log("<--socket error or timeout!\n");
close(ns);
break;
}
return retcode;
}
void proxy_freeaddrinfo(struct addrinfo *res) {
PFUNC();
free(res);
}
int connect_proxy_chain(int sock, ip_type target_ip,
unsigned short target_port, proxy_data * pd,
unsigned int proxy_count, chain_type ct, unsigned int max_chain) {
proxy_data p4;
proxy_data *p1, *p2, *p3;
int ns = -1;
int rc = -1;
unsigned int offset = 0;
unsigned int alive_count = 0;
unsigned int curr_len = 0;
unsigned int curr_pos = 0;
unsigned int looped = 0; // went back to start of list in RR mode
p3 = &p4;
PFUNC();
again:
rc = -1;
DUMP_PROXY_CHAIN(pd, proxy_count);
switch (ct) {
case DYNAMIC_TYPE:
alive_count = calc_alive(pd, proxy_count);
offset = 0;
do {
if(!(p1 = select_proxy(FIFOLY, pd, proxy_count, &offset)))
goto error_more;
} while(SUCCESS != start_chain(&ns, p1, DT) && offset < proxy_count);
for(;;) {
p2 = select_proxy(FIFOLY, pd, proxy_count, &offset);
if(!p2)
break;
if(SUCCESS != chain_step(ns, p1, p2)) {
PDEBUG("GOTO AGAIN 1\n");
goto again;
}
p1 = p2;
}
//proxychains_write_log(TP);
p3->ip = target_ip;
p3->port = target_port;
if(SUCCESS != chain_step(ns, p1, p3))
goto error;
break;
case ROUND_ROBIN_TYPE:
alive_count = calc_alive(pd, proxy_count);
curr_pos = offset = proxychains_proxy_offset;
if(alive_count < max_chain)
goto error_more;
PDEBUG("1:rr_offset = %d, curr_pos = %d\n", offset, curr_pos);
/* Check from current RR offset til end */
for (;rc != SUCCESS;) {
if (!(p1 = select_proxy(FIFOLY, pd, proxy_count, &offset))) {
/* We've reached the end of the list, go to the start */
offset = 0;
looped++;
continue;
} else if (looped && rc > 0 && offset >= curr_pos) {
PDEBUG("GOTO MORE PROXIES 0\n");
/* We've gone back to the start and now past our starting position */
proxychains_proxy_offset = 0;
goto error_more;
}
PDEBUG("2:rr_offset = %d\n", offset);
rc=start_chain(&ns, p1, RRT);
}
/* Create rest of chain using RR */
for(curr_len = 1; curr_len < max_chain;) {
PDEBUG("3:rr_offset = %d, curr_len = %d, max_chain = %d\n", offset, curr_len, max_chain);
p2 = select_proxy(FIFOLY, pd, proxy_count, &offset);
if(!p2) {
/* Try from the beginning to where we started */
offset = 0;
continue;
} else if(SUCCESS != chain_step(ns, p1, p2)) {
PDEBUG("GOTO AGAIN 1\n");
goto again;
} else
p1 = p2;
curr_len++;
}
//proxychains_write_log(TP);
p3->ip = target_ip;
p3->port = target_port;
proxychains_proxy_offset = offset+1;
PDEBUG("pd_offset = %d, curr_len = %d\n", proxychains_proxy_offset, curr_len);
if(SUCCESS != chain_step(ns, p1, p3))
goto error;
break;
case STRICT_TYPE:
alive_count = calc_alive(pd, proxy_count);
offset = 0;
if(!(p1 = select_proxy(FIFOLY, pd, proxy_count, &offset))) {
PDEBUG("select_proxy failed\n");
goto error_strict;
}
if(SUCCESS != start_chain(&ns, p1, ST)) {
PDEBUG("start_chain failed\n");
goto error_strict;
}
while(offset < proxy_count) {
if(!(p2 = select_proxy(FIFOLY, pd, proxy_count, &offset)))
break;
if(SUCCESS != chain_step(ns, p1, p2)) {
PDEBUG("chain_step failed\n");
goto error_strict;
}
p1 = p2;
}
//proxychains_write_log(TP);
p3->ip = target_ip;
p3->port = target_port;
if(SUCCESS != chain_step(ns, p1, p3))
goto error;
break;
case RANDOM_TYPE:
alive_count = calc_alive(pd, proxy_count);
if(alive_count < max_chain)
goto error_more;
curr_len = offset = 0;
do {
if(!(p1 = select_proxy(RANDOMLY, pd, proxy_count, &offset)))
goto error_more;
} while(SUCCESS != start_chain(&ns, p1, RT) && offset < max_chain);
while(++curr_len < max_chain) {
if(!(p2 = select_proxy(RANDOMLY, pd, proxy_count, &offset)))
goto error_more;
if(SUCCESS != chain_step(ns, p1, p2)) {
PDEBUG("GOTO AGAIN 2\n");
goto again;
}
p1 = p2;
}
//proxychains_write_log(TP);
p3->ip = target_ip;
p3->port = target_port;
if(SUCCESS != chain_step(ns, p1, p3))
goto error;
}
proxychains_write_log(TP " OK\n");
dup2(ns, sock);
close(ns);
return 0;
error:
if(ns != -1)
close(ns);
errno = ECONNREFUSED; // for nmap ;)
return -1;
error_more:
proxychains_write_log("\n!!!need more proxies!!!\n");
error_strict:
PDEBUG("error\n");
release_all(pd, proxy_count);
if(ns != -1)
close(ns);
errno = ETIMEDOUT;
return -1;
}
static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, char *user, char *pass) {
char *dns_name = NULL;
char hostnamebuf[MSG_LEN_MAX];
size_t dns_len = 0;
PFUNC();
// we use ip addresses with 224.* to lookup their dns name in our table, to allow remote DNS resolution
// the range 224-255.* is reserved, and it won't go outside (unless the app does some other stuff with
// the results returned from gethostbyname et al.)
// the hardcoded number 224 can now be changed using the config option remote_dns_subnet to i.e. 127
if(ip.octet[0] == remote_dns_subnet) {
dns_len = at_get_host_for_ip(ip, hostnamebuf);
if(!dns_len) goto err;
else dns_name = hostnamebuf;
}
PDEBUG("host dns %s\n", dns_name ? dns_name : "<NULL>");
size_t ulen = strlen(user);
size_t passlen = strlen(pass);
if(ulen > 0xFF || passlen > 0xFF || dns_len > 0xFF) {
proxychains_write_log(LOG_PREFIX "error: maximum size of 255 for user/pass or domain name!\n");
goto err;
}
int len;
unsigned char buff[BUFF_SIZE];
char ip_buf[16];
switch (pt) {
case HTTP_TYPE:{
if(!dns_len) {
pc_stringfromipv4(&ip.octet[0], ip_buf);
dns_name = ip_buf;
}
#define HTTP_AUTH_MAX ((0xFF * 2) + 1 + 1) /* 2 * 0xff: username and pass, plus 1 for ':' and 1 for zero terminator. */
char src[HTTP_AUTH_MAX];
char dst[(4 * HTTP_AUTH_MAX)];
if(ulen) {
snprintf(src, sizeof(src), "%s:%s", user, pass);
encode_base_64(src, dst, sizeof(dst));
} else dst[0] = 0;
len = snprintf((char *) buff, sizeof(buff),
"CONNECT %s:%d HTTP/1.0\r\n%s%s%s\r\n",
dns_name, ntohs(port),
ulen ? "Proxy-Authorization: Basic " : dst,
dst, ulen ? "\r\n" : dst);
if(len != send(sock, buff, len, 0))
goto err;
len = 0;
// read header byte by byte.
while(len < BUFF_SIZE) {
if(1 == read_n_bytes(sock, (char *) (buff + len), 1))
len++;
else
goto err;
if(len > 4 &&
buff[len - 1] == '\n' &&
buff[len - 2] == '\r' && buff[len - 3] == '\n' && buff[len - 4] == '\r')
break;
}
// if not ok (200) or response greather than BUFF_SIZE return BLOCKED;
if(len == BUFF_SIZE || !(buff[9] == '2' && buff[10] == '0' && buff[11] == '0')) {
PDEBUG("HTTP proxy blocked: buff=\"%s\"\n", buff);
return BLOCKED;
}
return SUCCESS;
}
break;
case SOCKS4_TYPE:{
buff[0] = 4; // socks version
buff[1] = 1; // connect command
memcpy(&buff[2], &port, 2); // dest port
if(dns_len) {
ip.octet[0] = 0;
ip.octet[1] = 0;
ip.octet[2] = 0;
ip.octet[3] = 1;
}
memcpy(&buff[4], &ip, 4); // dest host
len = ulen + 1; // username
if(len > 1)
memcpy(&buff[8], user, len);
else {
buff[8] = 0;
}
// do socksv4a dns resolution on the server
if(dns_len) {
memcpy(&buff[8 + len], dns_name, dns_len + 1);
len += dns_len + 1;
}
if((len + 8) != write_n_bytes(sock, (char *) buff, (8 + len)))
goto err;
if(8 != read_n_bytes(sock, (char *) buff, 8))
goto err;
if(buff[0] != 0 || buff[1] != 90)
return BLOCKED;
return SUCCESS;
}
break;
case SOCKS5_TYPE:{
int n_methods = ulen ? 2 : 1;
buff[0] = 5; // version
buff[1] = n_methods ; // number of methods
buff[2] = 0; // no auth method
if(ulen) buff[3] = 2; /// auth method -> username / password
if(2+n_methods != write_n_bytes(sock, (char *) buff, 2+n_methods))
goto err;
if(2 != read_n_bytes(sock, (char *) buff, 2))
goto err;
if(buff[0] != 5 || (buff[1] != 0 && buff[1] != 2)) {
if(buff[0] == 5 && buff[1] == 0xFF)
return BLOCKED;
else
goto err;
}
if(buff[1] == 2) {
// authentication
char in[2];
char out[515];
char *cur = out;
size_t c;
*cur++ = 1; // version
c = ulen & 0xFF;
*cur++ = c;
memcpy(cur, user, c);
cur += c;
c = passlen & 0xFF;
*cur++ = c;
memcpy(cur, pass, c);
cur += c;
if((cur - out) != write_n_bytes(sock, out, cur - out))
goto err;
if(2 != read_n_bytes(sock, in, 2))
goto err;
if(in[0] != 1 || in[1] != 0) {
if(in[0] != 1)
goto err;
else
return BLOCKED;
}
}
int buff_iter = 0;
buff[buff_iter++] = 5; // version
buff[buff_iter++] = 1; // connect
buff[buff_iter++] = 0; // reserved
if(!dns_len) {
buff[buff_iter++] = 1; // ip v4
memcpy(buff + buff_iter, &ip, 4); // dest host
buff_iter += 4;
} else {
buff[buff_iter++] = 3; //dns
buff[buff_iter++] = dns_len & 0xFF;
memcpy(buff + buff_iter, dns_name, dns_len);
buff_iter += dns_len;
}
memcpy(buff + buff_iter, &port, 2); // dest port
buff_iter += 2;
if(buff_iter != write_n_bytes(sock, (char *) buff, buff_iter))
goto err;
if(4 != read_n_bytes(sock, (char *) buff, 4))
goto err;
if(buff[0] != 5 || buff[1] != 0)
goto err;
switch (buff[3]) {
case 1:
len = 4;
break;
case 4:
len = 16;
break;
case 3:
len = 0;
if(1 != read_n_bytes(sock, (char *) &len, 1))
goto err;
break;
default:
goto err;
}
if(len + 2 != read_n_bytes(sock, (char *) buff, len + 2))
goto err;
return SUCCESS;
}
break;
}
err:
return SOCKET_ERROR;
}
/* stubs */
void CoreMixer_reset(struct CoreMixer* self) {
PFUNC();
if(self->type == CM_AMIGA)
Amiga_reset((struct Amiga*)self);
}
//override
void Soundblaster_fast(struct Soundblaster* self) {
PFUNC();
struct SBChannel *chan;
//d:Vector.<Number>,
Number* d;
int i = 0;
int mixed = 0;
int mixLen = 0;
int mixPos = 0;
struct SBSample *s = NULL;
struct Sample *sample = NULL;
//int size = self->bufferSize;
int size = CoreMixer_get_bufferSize(&self->super);
int toMix = 0;
Number value = NAN;
if (self->super.completed) {
if (!self->super.remains) return;
size = self->super.remains;
}
while (mixed < size) {
if (!self->super.samplesLeft) {
self->super.player->process(self->super.player);
self->super.player->fast(self->super.player);
self->super.samplesLeft = self->super.samplesTick;
if (self->super.completed) {
size = mixed +self->super.samplesTick;
if (size > CoreMixer_get_bufferSize(&self->super)) {
self->super.remains = size - CoreMixer_get_bufferSize(&self->super);
size = CoreMixer_get_bufferSize(&self->super);
}
}
}
toMix = self->super.samplesLeft;
if ((mixed + toMix) >= size) toMix = size - mixed;
mixLen = mixPos + toMix;
chan = &self->channels[0];
while (chan) {
if (!chan->enabled) {
chan = chan->next;
continue;
}
s = chan->sample;
d = s->data;
assert_op(mixPos, <, COREMIXER_MAX_BUFFER);
sample = &self->super.buffer[mixPos];
for (i = mixPos; i < mixLen; ++i) {
if (chan->index != chan->pointer) {
if (chan->index >= chan->length) {
if (!s->loopMode) {
chan->enabled = 0;
break;
} else {
chan->pointer = s->loopStart + (chan->index - chan->length);
chan->length = s->length;
if (s->loopMode == 2) {
if (!chan->dir) {
chan->dir = s->length + s->loopStart - 1;
} else {
chan->dir = 0;
}
}
}
} else chan->pointer = chan->index;
if (!chan->mute) {
unsigned int temp;
temp = chan->dir ? chan->dir - chan->pointer : chan->pointer;
assert_op(temp, <, SBSAMPLE_MAX_DATA);
value = d[temp];
chan->ldata = value * chan->lvol;
chan->rdata = value * chan->rvol;
} else {
chan->ldata = 0.0;
chan->rdata = 0.0;
}
}
chan->index = chan->pointer + chan->delta;
if ((chan->fraction += chan->speed) >= 1.0) {
chan->index++;
chan->fraction--;
}
sample->l += chan->ldata;
sample->r += chan->rdata;
sample = sample->next;
}
chan = chan->next;
}
int proxy_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {
struct gethostbyname_data ghdata;
struct addrinfo_data *space;
struct servent *se = NULL;
struct hostent *hp = NULL;
struct servent se_buf;
struct addrinfo *p;
char buf[1024];
int port;
PFUNC();
// printf("proxy_getaddrinfo node %s service %s\n",node,service);
space = calloc(1, sizeof(struct addrinfo_data));
if(!space) goto err1;
if(node && !inet_aton(node, &((struct sockaddr_in *) &space->sockaddr_space)->sin_addr)) {
/* some folks (nmap) use getaddrinfo() with AI_NUMERICHOST to check whether a string
containing a numeric ip was passed. we must return failure in that case. */
if(hints && (hints->ai_flags & AI_NUMERICHOST)) return EAI_NONAME;
hp = proxy_gethostbyname(node, &ghdata);
if(hp)
memcpy(&((struct sockaddr_in *) &space->sockaddr_space)->sin_addr,
*(hp->h_addr_list), sizeof(in_addr_t));
else
goto err2;
}
if(service) getservbyname_r(service, NULL, &se_buf, buf, sizeof(buf), &se);
port = se ? se->s_port : htons(atoi(service ? service : "0"));
((struct sockaddr_in *) &space->sockaddr_space)->sin_port = port;
*res = p = &space->addrinfo_space;
assert((size_t)p == (size_t) space);
p->ai_addr = &space->sockaddr_space;
if(node)
snprintf(space->addr_name, sizeof(space->addr_name), "%s", node);
p->ai_canonname = space->addr_name;
p->ai_next = NULL;
p->ai_family = space->sockaddr_space.sa_family = AF_INET;
p->ai_addrlen = sizeof(space->sockaddr_space);
if(hints) {
p->ai_socktype = hints->ai_socktype;
p->ai_flags = hints->ai_flags;
p->ai_protocol = hints->ai_protocol;
} else {
#ifndef AI_V4MAPPED
#define AI_V4MAPPED 0
#endif
p->ai_flags = (AI_V4MAPPED | AI_ADDRCONFIG);
}
goto out;
err2:
free(space);
err1:
return 1;
out:
return 0;
}
//override
void AmigaPlayer_toggle(struct AmigaPlayer* self, int index) {
PFUNC();
self->amiga->channels[index].mute ^= 1;
}
