//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; }