int
main(int argc, char *argv[])
{
int i;
char *x = 0;
int n = 100;
int p = getpagesize();
if (argc > 1) {
n = atoi(argv[1]);
}
rusage_init();
ldbg("Calling malloc for %d bytes\n", n * p);
x = (char *) malloc(n * p);
if (x == 0) {
perror("main: Unable to malloc");
exit(1);
}
ldbg("x = %p\n", x);
for (i = 0; i < n * p; i += p) {
x[i] = 'A';
}
rusage_print();
exit(0);
}
int
aio_sock_read(conn_t sd, void *buf, size_t count, void *reg_handle)
{
char *tmp = (char *) buf;
PRINT_TIME(sd, &tnow, &tprev,
"aio_sock_read: addr = %p count = %d handle %p", buf, count, reg_handle);
/* load up the buffer so we can later trigger an event */
if (request_count < REQUESTS_PER_CONN) {
ldbg("aio_sock_read: request_num = %d request = [%s]\n",
request_num, fake_requests[request_num]);
read_len = strlen(fake_requests[request_num]);
strncpy((char *) buf, fake_requests[request_num], count);
tmp[count] = '\0';
reg_verify(buf, count, reg_handle);
request_num++;
if (request_num >= FAKE_REQUESTS) {
request_num = 0;
}
} else {
ldbg("aio_sock_read: will return zero bytes (EOF)\n");
reg_verify(buf, count, reg_handle);
read_len = 0;
}
return 1;
}
void
reg_verify(void *buf, size_t count, void *reg_handle)
{
struct reg_entry *rptr = 0;
char *bufend = (char *) buf + count;
int i = 0;
int verified = 0;
PRINT_TIME(NOFD, &tnow, &tprev, "reg_verify: buf = %p count = %d "
"reg_handle = %p", buf, count, reg_handle);
for (i = 0; i < MAX_REGIONS; i++) {
rptr = &(reg_table[i]);
PRINT_TIME(NOFD, &tnow, &tprev, "reg_verify: i = %d start = %p "
"end = %p handle = %p", i, rptr->start, rptr->end, rptr->handle);
if (((char *) buf >= rptr->start) &&
((char *) bufend <= rptr->end) &&
((char *) reg_handle == rptr->handle)) {
PRINT_TIME(NOFD, &tnow, &tprev, "reg_verify: found match\n");
verified = 1;
break;
}
}
if (verified != 1) {
ldbg("reg_table_verify : unable to verify specified region\n");
ldbg("reg_table_verify : buf = %p count = %d bufend = %p "
"reg_handle = %p\n", buf, count, bufend, reg_handle);
reg_table_print();
exit(1);
}
}
void
reg_table_print(void)
{
struct reg_entry *rptr;
int i;
ldbg("Region Table Contents\n");
ldbg("%6s %20s %20s %20s\n", "index", "start", "end", "handle");
for (i = 0; i < MAX_REGIONS; i++) {
rptr = &(reg_table[i]);
ldbg("%6d %20p %20p %20p\n", i, rptr->start, rptr->end, rptr->handle);
}
ldbg("------------------------------\n");
}
/* This is only ever done once for each socket and it's
* done before we actually start serving anything so
* efficiency is not an issue.
*
* Not clear that there is a need to do set_not_special.
*/
void
sock_set_special(int sd)
{
if (sd > FD_SETSIZE && options.ignore_fd_setsize) {
printf
("sock_set_special: can't set special socket larger than FD_SETSIZE "
"permits\n");
printf("sock_set_special: sd = %d FD_SETSIZE = %d\n", sd, FD_SETSIZE);
exit(1);
}
assert(!FD_ISSET(sd, &special_set));
FD_SET(sd, &special_set);
if (sd > sock_special_max) {
sock_special_max = sd;
}
if (sd < sock_special_min) {
sock_special_min = sd;
}
if (min_usable_sd == -1) {
min_usable_sd = sd;
}
sock_special_num++;
first_regular_sd = sock_special_max + 1;
ldbg("sock_special_min %d max %d num %d\n",
sock_special_min, sock_special_max, sock_special_num);
}
static void
parse_options(int argc, char **argv)
{
int c;
while ((c = getopt(argc, argv, "u:hd")) != -1) {
switch (c) {
case 'h':
usage();
exit(EXIT_OK);
case 'd':
set_log_level(LOG_LEVEL_DBG);
break;
case 'u':
username = optarg;
break;
default:
usage();
exit(EXIT_CLIOPT_ERR);
}
}
/* get server hostname */
if (optind < argc) {
server = argv[optind];
ldbg ("Parsed server host name as %s", server);
optind++;
} else
{
fprintf(stderr, "ERROR: IVPN server hostname required\n\n");
usage();
exit(EXIT_CLIOPT_ERR);
}
/* get the optional port number */
if (optind < argc) {
port = atoi(argv[optind]);
ldbg ("Parsed server port as %u", port);
optind++;
}
if (optind < argc) {
fprintf(stderr, "ERROR: Extra arguments in command line\n\n");
usage();
exit(EXIT_CLIOPT_ERR);
}
}
static inline int check_tty_opened(struct rawbulk_function *fn) {
int opened;
unsigned long flags;
ldbg("%s\n", __func__);
spin_lock_irqsave(&fn->lock, flags);
opened = fn->tty_opened? 1: 0;
spin_unlock_irqrestore(&fn->lock, flags);
return opened;
}
static inline int check_enable_state(struct rawbulk_function *fn) {
int enab;
unsigned long flags;
ldbg("%s\n", __func__);
spin_lock_irqsave(&fn->lock, flags);
enab = fn->enable? 1: 0;
spin_unlock_irqrestore(&fn->lock, flags);
return enab;
}
static struct rawbulk_function *lookup_by_tty_minor(int minor) {
int n;
struct rawbulk_function *fn;
ldbg("%s\n", __func__);
for (n = 0; n < _MAX_TID; n ++) {
fn = prealloced_functions[n];
if (fn->tty_minor == minor)
return fn;
}
return NULL;
}
/**
* wm8350_reg_unlock()
*
* The WM8350 has a hardware lock which can be used to prevent writes to
* some registers (generally those which can cause particularly serious
* problems if misused). This function disables that lock so updates
* can be performed. For maximum safety this should be done only when
* required.
*/
int wm8350_reg_unlock(struct wm8350 *wm8350)
{
u16 key = WM8350_UNLOCK_KEY;
int ret;
ldbg(__func__);
mutex_lock(&io_mutex);
ret = wm8350_write(wm8350, WM8350_SECURITY, 1, &key);
if (ret)
dev_err(wm8350->dev, "unlock failed\n");
mutex_unlock(&io_mutex);
return ret;
}
static int
run_client()
{
int connfd = -1;
ldbg ("Client attempting to connect to %s:%u", server, port);
connfd = tcputil_connect(server, port);
if (connfd == -1)
return -1;
linfo ("Connected to %s:%u", server, port);
return control_channel_handler(connfd);
}
/*---------------------------------------------------------------------*/
unsigned long int
hash(char *uri)
{
unsigned long int ret = 0;
switch (USE_HASH) {
case USE_HASH_ADDITIVE:
ret = do_hash_additive(uri);
break;
case USE_HASH_BOB:
ret = do_hash_bob((unsigned char *) uri, strlen(uri), 0);
break;
default:
printf("hash: unknown hash function defined %d\n", USE_HASH);
exit(1);
break;
}
ldbg("hash: ret = %lu\n", ret);
return ret;
}
int rawbulk_check_enable(struct rawbulk_function *fn) {
ldbg("%s\n", __func__);
return check_enable_state(fn);
}
struct rawbulk_function *rawbulk_lookup_function(int transfer_id) {
ldbg("%s\n", __func__);
if (transfer_id >= 0 && transfer_id < _MAX_TID)
return prealloced_functions[transfer_id];
return NULL;
}
int rawbulk_function_setup(struct usb_function *f, const struct
usb_ctrlrequest *ctrl) {
struct rawbulk_function *fn = function_to_rbf(f);
unsigned int setdtr = 0;
unsigned int data_connect = 0;
struct usb_composite_dev *cdev = f->config->cdev;
struct usb_request *req = cdev->req;
int value = -EOPNOTSUPP;
u16 w_index = le16_to_cpu(ctrl->wIndex);
u16 w_value = le16_to_cpu(ctrl->wValue);
u16 w_length = le16_to_cpu(ctrl->wLength);
if(ctrl->bRequest) {
ldbg("ctrl->bRequestType = %0x ctrl->bRequest = %0x \n", ctrl->bRequestType, ctrl->bRequest);
}
switch(ctrl->bRequest) {
case 0x01:
if(ctrl->bRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {//0x40
// set/clear DTR
ldbg("setdtr = %d, w_value =%d\n", setdtr, w_value);
if(fn->activated){
setdtr = w_value & 0x01;
//schedule_work(&flow_control);
modem_dtr_set(setdtr, 0);
modem_dcd_state();
}
value = 0;
}
break;
case 0x02:
if(ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR)) {//0xC0
// DSR | CD109
//schedule_work(&dtr_status);
data_connect = modem_dcd_state();
//modem_dtr_query(&data_connect, 0);
if(fn->activated) {
if(data_connect && fn->enable) {
*((unsigned char *)req->buf) = 0x3;
ldbg("connect %d\n", data_connect);
}
else {
*((unsigned char *)req->buf) = 0x2;
ldbg("disconnect=%d, setdtr=%d\n", data_connect, setdtr);
}
}
else //set CD CSR state to 0 if modem bypass not inactive
*((unsigned char *)req->buf) = 0x0;
value = 1;
}
break;
case 0x03:
if(ctrl->bRequestType == (USB_DIR_OUT | USB_TYPE_VENDOR)) {//0x40
// xcvr
ldbg("CTRL SET XCVR 0x%02x\n", w_value);
value = 0;
}
break;
case 0x04:
if((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_VENDOR) {
if(ctrl->bRequestType & USB_DIR_IN) {//0xC0
// return ID
sprintf(req->buf, "CBP_8.2");
value = 1;
} else {//0x40
value = 0;
}
}
break;
case 0x05:
if(ctrl->bRequestType == (USB_DIR_IN | USB_TYPE_VENDOR)) {//0xC0
// connect status
ldbg("CTRL CONNECT STATUS\n");
*((unsigned char *)req->buf) = 0x0;
value = 1;
}
break;
default:
ldbg("invalid control req%02x.%02x v%04x i%04x l%d\n",
ctrl->bRequestType, ctrl->bRequest,
w_value, w_index, w_length);
}
// respond with data transfer or status phase?
if (value >= 0) {
req->zero = 0;
req->length = value;
req->complete = simple_setup_complete;
value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
if (value < 0)
printk(KERN_ERR "response err %d\n", value);
}
// device either stalls (value < 0) or reports success
return value;
}
/* Move SELF to the front of the LRU queue: */
void
lru_access(int sd)
{
int self;
assert(!sock_is_listener(sd));
if (sock_is_special(sd)) {
return;
}
self = info_index(sd);
if (self == NULL_INDEX) {
printf("lru_access: no mapping for sd = %d\n", sd);
exit(1);
}
if (LRU_DEBUG)
printf("%d: lru_access(%d) ->\n", (int) getpid(), self);
if (!(self < lru_size)) {
printf
("lru_access: trying to access element %d but lru array is of size %d\n",
self, lru_size);
exit(1);
}
lru[self].time = lru_now;
lru[self].sd = sd;
if (lru_head != lru_tail && self != lru_head) {
if (self == lru_tail) {
lru_tail = lru[self].prev;
} else {
lru[lru[self].prev].next = lru[self].next;
lru[lru[self].next].prev = lru[self].prev;
}
lru[self].next = lru_head;
lru[lru_head].prev = self;
lru_head = self;
}
if (LRU_DEBUG) {
int i, j, p = 0;
for (i = 0, j = lru_head; i < lru_size; ++i) {
printf(" %d@%d [%d,%d]", j, lru[j].sd, lru[j].prev, lru[j].next);
if (i > 0 && lru[j].prev != p)
printf(" -BAD!");
p = j;
j = lru[j].next;
printf("\n");
}
if (lru_tail != p) {
printf(" BAD lru_tail = %d p = %d", lru_tail, p);
}
printf("\n");
}
ldbg("lru_access: sd = %d self = %d lru_head = %d lru_tail = %d\n",
sd, lru_head, lru_tail, self);
}
