/*===============================================================================================*/
int test_socket(void)
{
ksocket_t sockfd_cli;
struct sockaddr_in addr_srv;
char buf[1024], *tmp;
int addr_len, len;
#ifdef KSOCKET_ADDR_SAFE
mm_segment_t old_fs;
old_fs = get_fs();
set_fs(KERNEL_DS);
#endif
memset(&addr_srv, 0, sizeof(addr_srv));
addr_srv.sin_family = AF_INET;
addr_srv.sin_port = htons(port);
addr_srv.sin_addr.s_addr = inet_addr("127.0.0.1");;
addr_len = sizeof(struct sockaddr_in);
sockfd_cli = ksocket(AF_INET, SOCK_STREAM, 0);
printk("sockfd_cli = 0x%p\n", sockfd_cli);
if (sockfd_cli == NULL)
{
printk("socket failed\n");
return -1;
}
if (kconnect(sockfd_cli, (struct sockaddr*)&addr_srv, addr_len) < 0)
{
printk("connect failed\n");
return -1;
}
//tmp = inet_ntoa(&addr_srv.sin_addr);
//printk("connected to : %s %d\n", tmp, ntohs(addr_srv.sin_port));
//kfree(tmp);
len = sprintf(buf, "%s", "Hello, This is what I send\n");
ksend(sockfd_cli, buf, len, 0);
memset(buf, 0, sizeof(buf));
krecv(sockfd_cli, buf, 1024, 0);
printk("got message : %s\n", buf);
kclose(sockfd_cli);
#ifdef KSOCKET_ADDR_SAFE
set_fs(old_fs);
#endif
return 0;
}
/* open */
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
int ret;
struct sock *sk;
socket_idesc_check(sockfd, sk);
if (!addr || (addrlen <= 0))
return SET_ERRNO(EINVAL);
ret = kconnect(sk, addr, addrlen, sk->idesc.idesc_flags);
if (ret < 0) {
return SET_ERRNO(-ret);
}
return 0;
}
int thread_fn() {
if(enable_update == 1){
// ksocket things
struct timeval start, stop;
struct sockaddr_in addr_srv;
int char_size = 21,rate = 50, recv_size,ctr = 0,thresh=100;
unsigned long cnt=0;
char buf[char_size], *tmp, bufs[24];
char extra[10];
int addr_len,len,ax,ay,az,count,axs,ays,azs;
unsigned long elapsed;
//float adx, ady, adz;
enable_count++;
#ifdef KSOCKET_ADDR_SAFE
mm_segment_t old_fs;
old_fs = get_fs();
set_fs(KERNEL_DS);
#endif
sprintf(current->comm, "ksockThrd");
/**buf = "Hello!";*/
memset(&addr_srv, 0, sizeof(addr_srv));
addr_srv.sin_family = AF_INET;
addr_srv.sin_port = htons(port);
addr_srv.sin_addr.s_addr = inet_addr(address);
addr_len = sizeof(struct sockaddr_in);
// Connect the socket
ca->sockfd_globl = ksocket(AF_INET, SOCK_STREAM, 0);
printk("sockfd_cli = 0x%p\n", ca->sockfd_globl);
if (ca->sockfd_globl == NULL){
printk("socket failed\n");
return -1;
}
if (kconnect(ca->sockfd_globl, (struct sockaddr*)&addr_srv, addr_len) < 0){
printk("connect failed\n");
return -1;
}
tmp = inet_ntoa(addr_srv.sin_addr);
printk("connected to : %s %d\n", tmp, ntohs(addr_srv.sin_port));
kfree(tmp);
rate = ca->rate;
len = sprintf(bufs, "%s%d%s%d", "03,ON,",10,",",10);
printk("Sending: %s\n",bufs);
ksend(ca->sockfd_globl, bufs, len, 0);
memset(bufs,'\0',sizeof(bufs));
ctr = thresh;
do_gettimeofday(&start);
while(1){
if(enable_update == 0){
printk(KERN_INFO "thread1 break\n");
printk(KERN_ALERT "Closing accl socket now!\n\n");
//kclose(sockfd_cli);
kclose(ca->sockfd_globl);
#ifdef KSOCKET_ADDR_SAFE
set_fs(old_fs);
#endif
break;
}
memset(buf,'\0',sizeof(buf));
//printk("1.buf:%s",buf);
if((recv_size = krecv(ca->sockfd_globl, buf, char_size, 0))>0){
//printk("buf:%s",buf);
//printk("bufs:%s\n",bufs);
count = sscanf(buf, "%d,%d,%d,%d,%d,%d\n%s",&ax,&axs,&ay,&ays,&az,&azs,extra);
//printk("recv_size:%d, count: %d\n",recv_size,count);
//printk("ax:%d, axs:%d, ay:%d,ays:%d, az:%d, azs:%d, extra: %s\n", ax,axs,ay,ays,az,azs,extra);
//Apply logic for sign
if(axs==1)
ax *= -1;
if(ays==1)
ay *= -1;
if(azs==1)
az *= -1;
input_report_abs(cloudaccl_input_dev, ABS_X, ax);
input_report_abs(cloudaccl_input_dev, ABS_Y, ay);
input_report_abs(cloudaccl_input_dev, ABS_Z, az);
input_sync(cloudaccl_input_dev);
ctr--;
cnt++;
//printk("Reported(%d)::ax:%d,ay:%d,az:%d\n", cnt,ax,ay,az);
if (ctr==0){
ctr=thresh;
do_gettimeofday(&stop);
elapsed = (stop.tv_sec-start.tv_sec)*1000000 + stop.tv_usec-start.tv_usec;
printk("Reported(%ld)::ax:%d,ay:%d,az:%d\n", cnt,ax,ay,az);
printk(KERN_ALERT "L:%d,%ld,%ld\n", enable_count,cnt,elapsed);
do_gettimeofday(&start);
}
}
//schedule();
}
}
return 0;
}
/*this handles the redirection from client to real server*/
void RedirectProc (ksocket_t SockfdFromClnt)
{
struct sockaddr_in RealSrvAddr, stRelayAddr, stTemp1, stTemp;
ksocket_t SockfdRelay;
int on = 1;
char frwd_buffer[BUFFER_SIZE];
int iRBytes, iWBytes, iNWritten, cur, iLen;
unsigned short iClntPort, server_port = 0;
/* kernel thread name*/
sprintf(current->comm, "krelaychld");
allow_signal(SIGKILL);
allow_signal(SIGTERM);
//Copy the values for later use
if ((kgetpeername(SockfdFromClnt, (struct sockaddr *)&stTemp1, &iLen)) < 0)
{
printk (KERN_ERR "kgetpeername() failed\n");
}
iClntPort = stTemp1.sin_port;
/*Create socket*/
if ((SockfdRelay = ksocket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
printk(KERN_ERR "Can't create socket.");
memset(&stRelayAddr, 0, sizeof(stRelayAddr));
stRelayAddr.sin_family = AF_INET;
stRelayAddr.sin_addr.s_addr = INADDR_ANY;
stRelayAddr.sin_port = htons(0);
if (ksetsockopt(SockfdRelay, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
{
printk(KERN_ERR "ksetsockopt(SO_REUSEADDR) failed\n");
}
/*Bind our local addrress so that client can send*/
if (kbind(SockfdRelay, (struct sockaddr *) &stRelayAddr, sizeof(stRelayAddr)) < 0)
{
printk(KERN_ERR "Can't bind local address\n");
return;
}
//printk (KERN_ERR "Relay eph port= %d", ntohs(stRelayAddr.sin_port));
//Need to analyze this part@@@@@@@@@
//Store the relay server ephemeral port (Y) in NAT
if (kgetsockname(SockfdRelay, (struct sockaddr *) &stTemp, &iLen) < 0)
{
printk(KERN_ERR "kgetpeername failed\n");
}
// printk (KERN_ERR "Relay eph port= %d", ntohs(stTemp.sin_port));
for (cur = 0; cur <= MAX_TBL_IDX -1; cur++)
{
if (stTbl[cur].iClntPort == iClntPort)
{
stTbl[cur].iRelayPort = stTemp.sin_port;
server_port = stTbl[cur].iClntSrvPort;
break;
}
}
if (0 == server_port)
{
printk (KERN_ERR "Error..Cannot get the server port\n");
kclose (SockfdRelay);
return;
}
//Connect to the Real server
RealSrvAddr.sin_family = PF_INET;
RealSrvAddr.sin_addr.s_addr = (inet_addr(DEF_REAL_IP));
RealSrvAddr.sin_port = server_port;
if (kconnect(SockfdRelay, (struct sockaddr *) &RealSrvAddr, sizeof(RealSrvAddr)) < 0)
{
printk(KERN_ERR "Connect failed\n");
}
for (;;)
{
//printk (KERN_ERR "trying krecv from client\n");
/* Read from Client and send to Real Server */
iRBytes = krecv(SockfdFromClnt, &frwd_buffer, BUFFER_SIZE - 8, MSG_DONTWAIT);
//printk (KERN_ERR "tried krecv = %d\n", iRBytes);
//Client Socket is closed
if (iRBytes == 0)
break;
iWBytes = 0;
iNWritten = 0;
//If some data is there to be read
while (iWBytes != iRBytes && iRBytes > 0)
{
if ((iNWritten = ksend(SockfdRelay, &frwd_buffer + iWBytes , iRBytes-iWBytes, 0)) < 0)
{
printk (KERN_ERR "error occured while writing to receiver\n");
return;
}
iWBytes += iNWritten;
}
//printk (KERN_ERR "trying krecv from real server\n");
/* Read from Real server and write to client */
iRBytes = krecv(SockfdRelay, &frwd_buffer, BUFFER_SIZE - 8, MSG_DONTWAIT);
//printk (KERN_ERR "tried krecv1 = %d\n", iRBytes);
if (iRBytes == 0)
break;
iWBytes = 0;
iNWritten = 0;
while (iWBytes != iRBytes && iRBytes > 0)
{
if ((iNWritten = ksend(SockfdFromClnt, &frwd_buffer + iWBytes , iRBytes-iWBytes, 0)) < 0)
{
printk (KERN_ERR "error occured while writing to receiver\n");
return;
}
iWBytes += iNWritten;
}
//Sleep for sometime
// mdelay (1);
}
(void)kclose(SockfdRelay);
(void)kclose(SockfdFromClnt);
}
static int led_perform_fn(u8 length,
u8 result_code,
u8 device_id,
u8 command,
u8 on_time,
u8 off_time)
{
printk(KERN_ALERT "In perform function\n");
printk(KERN_ALERT "Creating Socket now\n");
ksocket_t sockfd_cli;
struct sockaddr_in addr_srv;
char buf[1024], *tmp;
int addr_len,len;
#ifdef KSOCKET_ADDR_SAFE
mm_segment_t old_fs;
old_fs = get_fs();
set_fs(KERNEL_DS);
#endif
sprintf(current->comm, "ksktcli");
*buf = "Hello!";
memset(&addr_srv, 0, sizeof(addr_srv));
addr_srv.sin_family = AF_INET;
addr_srv.sin_port = htons(port);
addr_srv.sin_addr.s_addr = inet_addr("127.0.0.1");;
addr_len = sizeof(struct sockaddr_in);
sockfd_cli = ksocket(AF_INET, SOCK_STREAM, 0);
printk("sockfd_cli = 0x%p\n", sockfd_cli);
if (sockfd_cli == NULL)
{
printk("socket failed\n");
return -1;
}
if (kconnect(sockfd_cli, (struct sockaddr*)&addr_srv, addr_len) < 0)
{
printk("connect failed\n");
return -1;
}
tmp = inet_ntoa(addr_srv.sin_addr);
printk("connected to : %s %d\n", tmp, ntohs(addr_srv.sin_port));
kfree(tmp);
len = sprintf(buf, "%s", "This is dell led");
ksend(sockfd_cli, buf, len, 0);
krecv(sockfd_cli, buf, 1024, 0);
printk("got message : %s\n", buf);
printk(KERN_ALERT "Closing dell led socket now!\n");
kclose(sockfd_cli);
#ifdef KSOCKET_ADDR_SAFE
set_fs(old_fs);
#endif
return 0;
}
int SenderExp(hash *data_table, char *code)
{
ksocket_t cli_fd;
struct sockaddr_in srv_addr;
char *temp = 0x00;
int addr_len;
int opt = 1;
int i, r;
//listNode *pCur = 0;
#ifdef KSOCKET_ADDR_SAFE
mm_segment_t oldfs;
old_fs = get_fs();
set_fs(KERNEL_DS);
#endif
memset(&srv_addr, 0, sizeof(srv_addr));
srv_addr.sin_family = AF_INET;
srv_addr.sin_port = htons(SERVER_PORT);
srv_addr.sin_addr.s_addr = inet_addr(SERVER_ADDR);
addr_len = sizeof(struct sockaddr_in);
cli_fd = ksocket(AF_INET, SOCK_STREAM, 0);
if(cli_fd == 0)
{
return -1;
}
if(ksetsockopt(cli_fd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt)) < 0)
{
return -1;
}
if(kconnect(cli_fd, (struct sockaddr *)&srv_addr, addr_len) < 0)
{
return -1;
}
temp = inet_ntoa(&srv_addr.sin_addr);
printk("connected to : %s %d\n", temp, ntohs(srv_addr.sin_port));
kfree(temp);
if(strcmp(code, "exp") == 0)
{
r = SendHeader(cli_fd, code, data_table);
printk("hdr : %d\n", r);
for(i=0; i<HASH_SIZE; i++)
{
listNode *cur = data_table->item[i].head;
while(cur)
{
r = SendExpData(cli_fd, &(cur->data));
if (r <= 0) continue;
printk("payload : %d\n", r);
PrintData(&(cur->data));
cur = cur->next;
}
}
}
kclose(cli_fd);
#ifdef KSOCKET_ADDR_SAFE
set_fs(old_fs);
#endif
return 0;
}
