void __init prom_init(void) { ulong mem_size = get_mem_avail(); int reserve_size = 0; printk("Total Memory: %ld bytes\n", mem_size); reserve_buffer(CommandLine, mem_size); reserve_size = get_reserved_buffer_size(); mem_size -= reserve_size; add_memory_region(0x0,mem_size, BOOT_MEM_RAM); add_memory_region(mem_size,reserve_size, BOOT_MEM_RESERVED); printk("Main Memory: %ld bytes\n", mem_size); printk("Reserved Memory: %ld bytes at 0x%08x\n", get_reserved_buffer_size(), (ulong)get_reserved_buffer()); printk("Detected %s ASIC\n", GetAsicName()); mips_machgroup = MACH_GROUP_HP_LJ; mips_machtype = MACH_UNKNOWN; strcpy(arcs_cmdline, CommandLine+strlen(Delimiter)); }
void auth_finished (BSocksClient *o) { // allocate request buffer bsize_t size = bsize_fromsize(sizeof(struct socks_request_header)); switch (o->dest_addr.type) { case BADDR_TYPE_IPV4: size = bsize_add(size, bsize_fromsize(sizeof(struct socks_addr_ipv4))); break; case BADDR_TYPE_IPV6: size = bsize_add(size, bsize_fromsize(sizeof(struct socks_addr_ipv6))); break; } if (!reserve_buffer(o, size)) { report_error(o, BSOCKSCLIENT_EVENT_ERROR); return; } // write request struct socks_request_header header; header.ver = hton8(SOCKS_VERSION); header.cmd = hton8(SOCKS_CMD_CONNECT); header.rsv = hton8(0); switch (o->dest_addr.type) { case BADDR_TYPE_IPV4: { header.atyp = hton8(SOCKS_ATYP_IPV4); struct socks_addr_ipv4 addr; addr.addr = o->dest_addr.ipv4.ip; addr.port = o->dest_addr.ipv4.port; memcpy(o->buffer + sizeof(header), &addr, sizeof(addr)); } break; case BADDR_TYPE_IPV6: { header.atyp = hton8(SOCKS_ATYP_IPV6); struct socks_addr_ipv6 addr; memcpy(addr.addr, o->dest_addr.ipv6.ip, sizeof(o->dest_addr.ipv6.ip)); addr.port = o->dest_addr.ipv6.port; memcpy(o->buffer + sizeof(header), &addr, sizeof(addr)); } break; default: ASSERT(0); } memcpy(o->buffer, &header, sizeof(header)); // send request PacketPassInterface_Sender_Send(o->control.send_if, (uint8_t *)o->buffer, size.value); // set state o->state = STATE_SENDING_REQUEST; }
void send_handler_done (BSocksClient *o) { DebugObject_Access(&o->d_obj); ASSERT(o->buffer) switch (o->state) { case STATE_SENDING_HELLO: { BLog(BLOG_DEBUG, "sent hello"); // allocate buffer for receiving hello bsize_t size = bsize_fromsize(sizeof(struct socks_server_hello)); if (!reserve_buffer(o, size)) { goto fail; } // receive hello start_receive(o, (uint8_t *)o->buffer, size.value); // set state o->state = STATE_SENT_HELLO; } break; case STATE_SENDING_REQUEST: { BLog(BLOG_DEBUG, "sent request"); // allocate buffer for receiving reply bsize_t size = bsize_add( bsize_fromsize(sizeof(struct socks_reply_header)), bsize_max(bsize_fromsize(sizeof(struct socks_addr_ipv4)), bsize_fromsize(sizeof(struct socks_addr_ipv6))) ); if (!reserve_buffer(o, size)) { goto fail; } // receive reply header start_receive(o, (uint8_t *)o->buffer, sizeof(struct socks_reply_header)); // set state o->state = STATE_SENT_REQUEST; } break; case STATE_SENDING_PASSWORD: { BLog(BLOG_DEBUG, "send password"); // allocate buffer for receiving reply bsize_t size = bsize_fromsize(2); if (!reserve_buffer(o, size)) { goto fail; } // receive reply header start_receive(o, (uint8_t *)o->buffer, size.value); // set state o->state = STATE_SENT_PASSWORD; } break; default: ASSERT(0); } return; fail: report_error(o, BSOCKSCLIENT_EVENT_ERROR); }
void recv_handler_done (BSocksClient *o, int data_len) { ASSERT(data_len >= 0) ASSERT(data_len <= o->control.recv_total - o->control.recv_len) DebugObject_Access(&o->d_obj); o->control.recv_len += data_len; if (o->control.recv_len < o->control.recv_total) { do_receive(o); return; } switch (o->state) { case STATE_SENT_HELLO: { BLog(BLOG_DEBUG, "received hello"); struct socks_server_hello imsg; memcpy(&imsg, o->buffer, sizeof(imsg)); if (ntoh8(imsg.ver) != SOCKS_VERSION) { BLog(BLOG_NOTICE, "wrong version"); goto fail; } size_t auth_index; for (auth_index = 0; auth_index < o->num_auth_info; auth_index++) { if (o->auth_info[auth_index].auth_type == ntoh8(imsg.method)) { break; } } if (auth_index == o->num_auth_info) { BLog(BLOG_NOTICE, "server didn't accept any authentication method"); goto fail; } const struct BSocksClient_auth_info *ai = &o->auth_info[auth_index]; switch (ai->auth_type) { case SOCKS_METHOD_NO_AUTHENTICATION_REQUIRED: { BLog(BLOG_DEBUG, "no authentication"); auth_finished(o); } break; case SOCKS_METHOD_USERNAME_PASSWORD: { BLog(BLOG_DEBUG, "password authentication"); if (ai->password.username_len == 0 || ai->password.username_len > 255 || ai->password.password_len == 0 || ai->password.password_len > 255 ) { BLog(BLOG_NOTICE, "invalid username/password length"); goto fail; } // allocate password packet bsize_t size = bsize_fromsize(1 + 1 + ai->password.username_len + 1 + ai->password.password_len); if (!reserve_buffer(o, size)) { goto fail; } // write password packet char *ptr = o->buffer; *ptr++ = 1; *ptr++ = ai->password.username_len; memcpy(ptr, ai->password.username, ai->password.username_len); ptr += ai->password.username_len; *ptr++ = ai->password.password_len; memcpy(ptr, ai->password.password, ai->password.password_len); ptr += ai->password.password_len; // start sending PacketPassInterface_Sender_Send(o->control.send_if, (uint8_t *)o->buffer, size.value); // set state o->state = STATE_SENDING_PASSWORD; } break; default: ASSERT(0); } } break; case STATE_SENT_REQUEST: { BLog(BLOG_DEBUG, "received reply header"); struct socks_reply_header imsg; memcpy(&imsg, o->buffer, sizeof(imsg)); if (ntoh8(imsg.ver) != SOCKS_VERSION) { BLog(BLOG_NOTICE, "wrong version"); goto fail; } if (ntoh8(imsg.rep) != SOCKS_REP_SUCCEEDED) { BLog(BLOG_NOTICE, "reply not successful"); goto fail; } int addr_len; switch (ntoh8(imsg.atyp)) { case SOCKS_ATYP_IPV4: addr_len = sizeof(struct socks_addr_ipv4); break; case SOCKS_ATYP_IPV6: addr_len = sizeof(struct socks_addr_ipv6); break; default: BLog(BLOG_NOTICE, "reply has unknown address type"); goto fail; } // receive the rest of the reply start_receive(o, (uint8_t *)o->buffer + sizeof(imsg), addr_len); // set state o->state = STATE_RECEIVED_REPLY_HEADER; } break; case STATE_SENT_PASSWORD: { BLog(BLOG_DEBUG, "received password reply"); if (o->buffer[0] != 1) { BLog(BLOG_NOTICE, "password reply has unknown version"); goto fail; } if (o->buffer[1] != 0) { BLog(BLOG_NOTICE, "password reply is negative"); goto fail; } auth_finished(o); } break; case STATE_RECEIVED_REPLY_HEADER: { BLog(BLOG_DEBUG, "received reply rest"); // free buffer BFree(o->buffer); o->buffer = NULL; // free control I/O free_control_io(o); // init up I/O init_up_io(o); // set state o->state = STATE_UP; // call handler o->handler(o->user, BSOCKSCLIENT_EVENT_UP); return; } break; default: ASSERT(0); } return; fail: report_error(o, BSOCKSCLIENT_EVENT_ERROR); }
void connector_handler (BSocksClient* o, int is_error) { DebugObject_Access(&o->d_obj); ASSERT(o->state == STATE_CONNECTING) // check connection result if (is_error) { // PSIPHON // BLog(BLOG_ERROR, "connection failed"); BLog(BLOG_WARNING, "connection failed"); goto fail0; } // init connection if (!BConnection_Init(&o->con, BConnection_source_connector(&o->connector), o->reactor, o, (BConnection_handler)connection_handler)) { BLog(BLOG_ERROR, "BConnection_Init failed"); goto fail0; } BLog(BLOG_DEBUG, "connected"); // init control I/O init_control_io(o); // check number of methods if (o->num_auth_info == 0 || o->num_auth_info > 255) { BLog(BLOG_ERROR, "invalid number of authentication methods"); goto fail1; } // allocate buffer for sending hello bsize_t size = bsize_add( bsize_fromsize(sizeof(struct socks_client_hello_header)), bsize_mul( bsize_fromsize(o->num_auth_info), bsize_fromsize(sizeof(struct socks_client_hello_method)) ) ); if (!reserve_buffer(o, size)) { goto fail1; } // write hello header struct socks_client_hello_header header; header.ver = hton8(SOCKS_VERSION); header.nmethods = hton8(o->num_auth_info); memcpy(o->buffer, &header, sizeof(header)); // write hello methods for (size_t i = 0; i < o->num_auth_info; i++) { struct socks_client_hello_method method; method.method = hton8(o->auth_info[i].auth_type); memcpy(o->buffer + sizeof(header) + i * sizeof(method), &method, sizeof(method)); } // send PacketPassInterface_Sender_Send(o->control.send_if, (uint8_t *)o->buffer, size.value); // set state o->state = STATE_SENDING_HELLO; return; fail1: free_control_io(o); BConnection_Free(&o->con); fail0: report_error(o, BSOCKSCLIENT_EVENT_ERROR); return; }
static int read_frames(pcm_reader_t *reader, void *buffer, unsigned nframes) { limiter_t *self = (limiter_t *)reader; unsigned i, n, res, nch = self->format.channels_per_frame; size_t bytes = nframes * pcm_get_format(self->src)->bytes_per_frame; buffer_t *ibp = &self->buffers[nch]; float *obp = buffer; do { if (reserve_buffer(ibp, bytes, 1) < 0) return -1; res = pcm_read_frames(self->src, ibp->data, nframes); for (n = 0; n < nch; ++n) { float *ip = (float *)ibp->data, *x; buffer_t *bp = &self->buffers[n]; unsigned end, limit; if (reserve_buffer(bp, bp->count + res, sizeof(float)) < 0) return -1; x = bp->data; for (i = 0; i < res; ++i) x[bp->count++] = pcm_clip(ip[i * nch + n], -3.0, 3.0); limit = bp->count; if (limit > 0 && res > 0) { float last = x[limit - 1]; for (; limit > 0 && x[limit-1] * last > 0; --limit) ; } end = bp->head; while (end < limit) { unsigned start, peak_pos; float peak; for (peak_pos = end; peak_pos < limit; ++peak_pos) if (x[peak_pos] > 1.0f || x[peak_pos] < -1.0f) break; if (peak_pos == limit) break; start = peak_pos; peak = fabs(x[peak_pos]); while (start > bp->head && x[peak_pos] * x[start] >= 0.0f) --start; ++start; for (end = peak_pos + 1; end < limit; ++end) { float y; if (x[peak_pos] * x[end] < 0.0f) break; y = fabs(x[end]); if (y > peak) { peak = y; peak_pos = end; } } if (peak < 2.0f) { float a = (peak - 1.0f) / (peak * peak); if (x[peak_pos] > 0.0f) a = -a; for (i = start; i < end; ++i) x[i] = x[i] + a * x[i] * x[i]; } else { float u = peak, v = 1.0f; float a = (u - 2.0f * v) / (u * u * u); float b = (3.0f * v - 2.0f * u) / (u * u); if (x[peak_pos] < 0.0f) b = -b; for (i = start; i < end; ++i) x[i] = x[i] + b * x[i] * x[i] + a * x[i] * x[i] * x[i]; } } bp->head = limit; } res = nframes; for (n = 0; n < nch; ++n) if (self->buffers[n].head < res) res = self->buffers[n].head; for (i = 0; i < res; ++i) for (n = 0; n < nch; ++n) *obp++ = ((float *)self->buffers[n].data)[i]; if (res) { for (n = 0; n < nch; ++n) { buffer_t *bp = &self->buffers[n]; float *p = bp->data; memmove(p, p + res, (bp->count - res) * sizeof(float)); bp->count -= res; bp->head -= res; } } } while (res == 0 && self->buffers[0].count); self->position += res; return res; }