//-----------------------------------------------------------------------------
static int
__init gtpusp_tg_init(void)
//-----------------------------------------------------------------------------
{
int err;
pr_info(MODULE_NAME": Initializing module (KVersion: %d)\n", KVERSION);
pr_info(MODULE_NAME": Copyright Polaris Networks 2010-2011\n");
pr_info(MODULE_NAME": Modified by EURECOM Lionel GAUTHIER 2014\n");
#ifndef CMAKER
pr_info(MODULE_NAME": Compiled %s at time %s\n",__DATE__,__TIME__);
#endif
#if defined(WITH_IPV6)
pr_info(MODULE_NAME": IPv4/IPv6 enabled\n");
#else
pr_info(MODULE_NAME": IPv4 only enabled\n");
#endif
pr_info(MODULE_NAME": params gtpu_enb_port=%u, gtpu_sgw_port=%u, sgw_addr=%s\n",
gtpu_enb_port, gtpu_sgw_port, sgw_addr);
// UDP socket socket
memset(&_gtpusp_sock, 0, sizeof(gtpusp_sock_t));
/* create a socket */
if ((err = sock_create(AF_INET, SOCK_DGRAM, IPPROTO_UDP, &_gtpusp_sock.sock)) < 0 ) {
PR_INFO(": Could not create a datagram socket, error = %d\n", -ENXIO);
return err;
}
_gtpusp_sock.addr.sin_family = AF_INET;
_gtpusp_sock.addr.sin_port = htons(gtpu_sgw_port);
_gtpusp_sock.addr.sin_addr.s_addr = in_aton(sgw_addr);
_gtpusp_sock.addr_send.sin_family = AF_INET;
_gtpusp_sock.addr_send.sin_port = htons(gtpu_enb_port);
_gtpusp_sock.addr_send.sin_addr.s_addr = in_aton(sgw_addr);
_gtpusp_sock.thread_stop_requested = 0;
if ( (err = _gtpusp_sock.sock->ops->bind(_gtpusp_sock.sock, (struct sockaddr *)&_gtpusp_sock.addr, sizeof(struct sockaddr) ) ) < 0) {
pr_info(MODULE_NAME": Could not bind socket, error = %d\n", -err);
goto close_and_out;
}
// start kernel thread
_gtpusp_sock.thread = kthread_run((void *)_udp_thread, NULL, MODULE_NAME);
if (IS_ERR(_gtpusp_sock.thread)) {
pr_info(MODULE_NAME": unable to start kernel thread\n");
return -ENOMEM;
}
if((_gtpusp_sock.thread)) {
wake_up_process(_gtpusp_sock.thread);
}
return xt_register_targets(gtpusp_tg_reg, ARRAY_SIZE(gtpusp_tg_reg));
close_and_out:
sock_release(_gtpusp_sock.sock);
_gtpusp_sock.sock = NULL;
return err;
}
static int __init init(void)
{
printk("%s\n","insmod skb_diy module\n");
cp_dev_xmit_tcp (ETH, SMAC, DMAC,NULL, 0,
in_aton(SIP),in_aton(DIP),
htons(SPORT),htons(DPORT),
0, 0, 0, 0);
return 0;
}
/* Allocate new target (from boot/module param) and setup netpoll for it */
static struct brcm_netconsole_target *alloc_param_target(char *target_config)
{
int err = -ENOMEM;
struct brcm_netconsole_target *nt;
u8 remote_mac[ETH_ALEN];
/*
* Allocate and initialize with defaults.
* Note that these targets get their config_item fields zeroed-out.
*/
nt = kzalloc(sizeof(*nt), GFP_KERNEL);
if (!nt) {
pr_err("brcm_netconsole: failed to allocate memory\n");
goto fail;
}
nt->np.name = "brcm_netconsole";
strlcpy(nt->np.dev_name, "rndis0", IFNAMSIZ);
nt->np.local_port = 5042;
nt->np.remote_port = 5042;
remote_mac[0] = 0xaa;
remote_mac[1] = 0xbb;
remote_mac[2] = 0xcc;
remote_mac[3] = 0xdd;
remote_mac[4] = 0xee;
remote_mac[5] = 0xff;
memcpy(nt->np.remote_mac, remote_mac, ETH_ALEN);
nt->np.remote_ip = in_aton("255.255.255.255");
nt->np.local_ip = in_aton("192.168.42.129");
/* Parse parameters and setup netpoll */
#if 0 /* kevin */
err = netpoll_parse_options(&nt->np, target_config);
if (err)
goto fail;
#endif
err = netpoll_setup(&nt->np);
if (err)
goto fail;
nt->enabled = 1;
nt_enabled = TRUE;
return nt;
fail:
kfree(nt);
return ERR_PTR(err);
}
static int __init init(void)
{
printk("nf_nat_rtsp v" IP_NF_RTSP_VERSION " loading\n");
if (stunaddr != NULL)
extip = in_aton(stunaddr);
if (destaction != NULL) {
if (strcmp(destaction, "auto") == 0)
dstact = DSTACT_AUTO;
if (strcmp(destaction, "strip") == 0)
dstact = DSTACT_STRIP;
if (strcmp(destaction, "none") == 0)
dstact = DSTACT_NONE;
}
BUG_ON(rcu_dereference(nf_nat_rtsp_hook));
RCU_INIT_POINTER(nf_nat_rtsp_hook, help);
BUG_ON(rcu_dereference(nf_nat_rtsp_hook_expectfn));
RCU_INIT_POINTER(nf_nat_rtsp_hook_expectfn, expected);
return 0;
}
int proc_lasat_ip(ctl_table *table, int write,
void *buffer, size_t *lenp, loff_t *ppos)
{
unsigned int ip;
char *p, c;
int len;
char ipbuf[32];
if (!table->data || !table->maxlen || !*lenp ||
(*ppos && !write)) {
*lenp = 0;
return 0;
}
if (write) {
len = 0;
p = buffer;
while (len < *lenp) {
if (get_user(c, p++))
return -EFAULT;
if (c == 0 || c == '\n')
break;
len++;
}
if (len >= sizeof(ipbuf)-1)
len = sizeof(ipbuf) - 1;
if (copy_from_user(ipbuf, buffer, len))
return -EFAULT;
ipbuf[len] = 0;
*ppos += *lenp;
/* Now see if we can convert it to a valid IP */
ip = in_aton(ipbuf);
*(unsigned int *)(table->data) = ip;
lasat_write_eeprom_info();
} else {
ip = *(unsigned int *)(table->data);
sprintf(ipbuf, "%d.%d.%d.%d",
(ip) & 0xff,
(ip >> 8) & 0xff,
(ip >> 16) & 0xff,
(ip >> 24) & 0xff);
len = strlen(ipbuf);
if (len > *lenp)
len = *lenp;
if (len)
if (copy_to_user(buffer, ipbuf, len))
return -EFAULT;
if (len < *lenp) {
if (put_user('\n', ((char *) buffer) + len))
return -EFAULT;
len++;
}
*lenp = len;
*ppos += len;
}
return 0;
}
int myclient(void) {
struct socket *sock;
struct sockaddr_in s_addr;
unsigned short portnum = 0x8888;
int ret = 0;
memset(&s_addr, 0, sizeof(s_addr));
s_addr.sin_family = AF_INET;
s_addr.sin_port = htons(portnum);
s_addr.sin_addr.s_addr = in_aton("192.168.209.134"); /*server ip is 192.168.209.134*/
sock = (struct socket *) kmalloc(sizeof(struct socket), GFP_KERNEL);
/*create a socket*/
ret = sock_create_kern(AF_INET, SOCK_STREAM, 0, &sock);
if (ret < 0) {
printk("client:socket create error!\n");
return ret;
}
printk("client: socket create ok!\n");
/*connect server*/
ret = sock->ops->connect(sock, (struct sockaddr *) &s_addr, sizeof(s_addr), 0);
if (ret != 0) {
printk("client:connect error!\n");
return ret;
}
printk("client:connect ok!\n");
/*kmalloc sendbuf*/
char *sendbuf = NULL;
sendbuf = kmalloc(1024, GFP_KERNEL);
if (sendbuf == NULL) {
printk("client: sendbuf kmalloc error!\n");
return -1;
}
memset(sendbuf, 1, 1024);
struct kvec vec;
struct msghdr msg;
vec.iov_base = sendbuf;
vec.iov_len = 1024;
memset(&msg, 0, sizeof(msg));
ret = kernel_sendmsg(sock, &msg, &vec, 1, 1024); /*send message */
if (ret < 0) {
printk("client: kernel_sendmsg error!\n");
return ret;
} else if (ret != 1024) {
printk("client: ret!=1024");
}
printk("client:send ok!\n");
return ret;
}
inline void sock_make_sockaddr_in(const char *ipaddr, const int port, struct sockaddr_in *sockaddr_out)
{
memset(sockaddr_out, 0, sizeof(struct sockaddr_in) );
sockaddr_out->sin_family = AF_INET;
sockaddr_out->sin_port = htons(port);
if( ipaddr )
sockaddr_out->sin_addr.s_addr = in_aton(ipaddr);
else
sockaddr_out->sin_addr.s_addr = htonl(INADDR_ANY);
}
int send(struct socket *sock, struct sockaddr_in *addr, void * data, int len)
{
struct msghdr msg;
struct iovec iov;
mm_segment_t oldfs;
int size = 0;
u_int32_t space;
if (sock->sk==NULL)
return 0;
int interface=1;
if(sock_setsockopt(sock,SOL_SOCKET,SO_BROADCAST,(char *)&interface,sizeof(interface))<0)
{
printk(KERN_WARNING "No Broadcast");
}
iov.iov_base = (char *) data;
iov.iov_len = len;
memset(&my_work->addr, 0, sizeof(struct sockaddr));
memset(&my_work->addr_send, 0, sizeof(struct sockaddr));
my_work->addr_send.sin_family = AF_INET;
//my_work->addr_send.sin_addr.s_addr = htonl(INADDR_SEND);
my_work->addr_send.sin_addr.s_addr = in_aton("255.255.255.255");
//sock->sk->sk_flags.SOCK_BROADCAST=1;
my_work->addr_send.sin_port = htons(CONNECT_PORT);
msg.msg_flags = 0;
msg.msg_name = (void *) & my_work->addr_send;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
if((space = sock_wspace(sock->sk))<len)
{
printk(KERN_INFO "ERROR");
return -ENOMEM;
}
sock_set_flag(my_work->sock_send,SOCK_BROADCAST);
//sock->sk->broadcast=1;
oldfs = get_fs();
set_fs(KERNEL_DS);
size = sock_sendmsg(sock,&msg,len);
if(size<0)
printk(KERN_WARNING "ERROR SEND MSG:%d:",size);
set_fs(oldfs);
// printk(KERN_INFO MODULE_NAME":Message Sent from new program");
return size;
}
static void sendmsg(struct work_struct *dummy)
{
int n;
struct sockaddr_in addr;
memset(&addr, 0x00, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(1000);
addr.sin_addr.s_addr = in_aton("61.139.2.69");
n = udp_sendto(sock, buffer, 128, 0, (struct sockaddr *)&addr,
sizeof(addr));
printk("send %i bytes/n", n);
}
/* 回环设备的初始化 */
int
loopback_init(struct device *dev)
{
dev->mtu = 2000; /* MTU */
dev->tbusy = 0;
dev->hard_start_xmit = loopback_xmit;
dev->open = NULL;
#if 1
dev->hard_header = eth_header;
dev->add_arp = NULL;
dev->hard_header_len = ETH_HLEN; /* 14 */
dev->addr_len = ETH_ALEN; /* 6 */
dev->type = ARPHRD_ETHER; /* 0x0001 */
dev->type_trans = eth_type_trans;
dev->rebuild_header = eth_rebuild_header;
#else
dev->hard_header_length = 0;
dev->add_arp = NULL;
dev->addr_len = 0;
dev->type = 0; /* loopback_type (0) */
dev->hard_header = NULL;
dev->type_trans = NULL;
dev->rebuild_header = NULL;
#endif
dev->queue_xmit = dev_queue_xmit;
/* New-style flags. */
dev->flags = IFF_LOOPBACK;
dev->family = AF_INET;
dev->pa_addr = in_aton("127.0.0.1");
dev->pa_brdaddr = in_aton("127.255.255.255");
dev->pa_mask = in_aton("255.0.0.0");
dev->pa_alen = sizeof(unsigned long);
dev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL);
memset(dev->priv, 0, sizeof(struct enet_statistics));
dev->get_stats = get_stats;
return(0);
};
struct p9_transport *p9_trans_create_tcp(const char *addr, int port)
{
int err;
struct p9_transport *trans;
struct socket *csocket;
struct sockaddr_in sin_server;
csocket = NULL;
trans = kmalloc(sizeof(struct p9_transport), GFP_KERNEL);
if (!trans)
return ERR_PTR(-ENOMEM);
trans->write = p9_fd_write;
trans->read = p9_fd_read;
trans->close = p9_fd_close;
trans->poll = p9_fd_poll;
sin_server.sin_family = AF_INET;
sin_server.sin_addr.s_addr = in_aton(addr);
sin_server.sin_port = htons(port);
sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
if (!csocket) {
P9_EPRINTK(KERN_ERR, "p9_trans_tcp: problem creating socket\n");
err = -EIO;
goto error;
}
err = csocket->ops->connect(csocket,
(struct sockaddr *)&sin_server,
sizeof(struct sockaddr_in), 0);
if (err < 0) {
P9_EPRINTK(KERN_ERR,
"p9_trans_tcp: problem connecting socket to %s\n",
addr);
goto error;
}
err = p9_socket_open(trans, csocket);
if (err < 0)
goto error;
return trans;
error:
if (csocket)
sock_release(csocket);
kfree(trans);
return ERR_PTR(err);
}
int lb_sendmsg (char *msgdata, int size)
{
int len;
struct msghdr msg;
struct iovec iov;
mm_segment_t oldfs;
struct sockaddr_in to;
/* initialize and setup socket to send messages to bare */
printk(KERN_DEBUG "LB_SOCKET T101 start: lb_sendmsg() msg: %s \n", msgdata);
if( sock_create( PF_INET,SOCK_DGRAM,IPPROTO_UDP,&clientsocket)<0 ){
printk( KERN_DEBUG "LB_SOCKET: lb_sendmsg() TERROR001: server: Error creating clientsocket \n" );
return -EIO;
}
memset(&to,0, sizeof(to));
to.sin_family = AF_INET;
to.sin_addr.s_addr = in_aton(ipaddr);
/* bare PC destination address */
to.sin_port = htons( (unsigned short) SERVERPORT );
memset(&msg,0,sizeof(msg));
msg.msg_name = &to;
msg.msg_namelen = sizeof(to);
iov.iov_base = msgdata;
iov.iov_len = size;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
oldfs = get_fs();
set_fs( KERNEL_DS );
len = sock_sendmsg( clientsocket, &msg, size );
set_fs( oldfs );
/* close socket */
if( clientsocket )
{
/*msleep_interruptible(HZ*2);*/
sock_release( clientsocket );
printk(KERN_DEBUG "LB_SOCKET T102 close socket: lb_sendmsg() \n");
if( com_thread_pid ) {
kill_proc_info( com_thread_pid, SIGTERM, 0 );
wait_for_completion( &threadcomplete );
}
}
printk(KERN_DEBUG "LB_SOCKET T103 end: lb_sendmsg() \n");
return len;
}
static struct sockaddr_in *new_addr(char *addr, unsigned short port)
{
struct sockaddr_in *sin;
sin = um_kmalloc(sizeof(struct sockaddr_in));
if(sin == NULL){
printk("new_addr: allocation of sockaddr_in failed\n");
return NULL;
}
sin->sin_family = AF_INET;
sin->sin_addr.s_addr = in_aton(addr);
sin->sin_port = htons(port);
return sin;
}
/* Initialize the rest of the LOOPBACK device. */
int loopback_init(struct device *dev)
{
int i;
dev->mtu = LOOPBACK_MTU;
dev->tbusy = 0;
dev->hard_start_xmit = loopback_xmit;
dev->hard_header = eth_header;
dev->hard_header_len = ETH_HLEN; /* 14 */
dev->addr_len = ETH_ALEN; /* 6 */
dev->tx_queue_len = 50000; /* No limit on loopback */
dev->type = ARPHRD_LOOPBACK; /* 0x0001 */
dev->rebuild_header = eth_rebuild_header;
dev->open = loopback_open;
dev->flags = IFF_LOOPBACK|IFF_BROADCAST;
dev->family = AF_INET;
#ifdef CONFIG_INET
dev->pa_addr = in_aton("127.0.0.1");
dev->pa_brdaddr = in_aton("127.255.255.255");
dev->pa_mask = in_aton("255.0.0.0");
dev->pa_alen = 4;
#endif
dev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL);
if (dev->priv == NULL)
return -ENOMEM;
memset(dev->priv, 0, sizeof(struct enet_statistics));
dev->get_stats = get_stats;
/*
* Fill in the generic fields of the device structure.
*/
for (i = 0; i < DEV_NUMBUFFS; i++)
skb_queue_head_init(&dev->buffs[i]);
return(0);
};
__initfunc(int whitehole_init(struct device *dev))
{
dev->priv = kmalloc(sizeof(struct net_device_stats), GFP_KERNEL);
if (dev->priv == NULL)
return -ENOBUFS;
memset(dev->priv, 0, sizeof(struct net_device_stats));
dev->get_stats = whitehole_get_stats;
dev->hard_start_xmit = whitehole_xmit;
dev->open = whitehole_open;
dev->stop = whitehole_close;
ether_setup(dev);
dev->tx_queue_len = 0;
dev->flags |= IFF_NOARP;
dev->flags &= ~(IFF_BROADCAST|IFF_MULTICAST);
dev->iflink = 0;
whitehole_iph.ihl = 5;
whitehole_iph.version = 4;
whitehole_iph.ttl = 2;
whitehole_iph.saddr = in_aton("193.233.7.21");
whitehole_iph.daddr = in_aton("193.233.7.10");
whitehole_iph.tot_len = htons(20);
whitehole_iph.check = ip_compute_csum((void *)&whitehole_iph, 20);
return 0;
}
void send_answer(struct work_struct *data){
// reader rtp_q, get istream and reader from container_of(data)
// queue bytes on corresponding kfifo
struct wq_wrapper *foo;
int len;
if(in_interrupt()) printk("udpsrvcallback: in interrupt3\n");
if(in_atomic()) printk("udpsrvcallback: in atomic3\n");
foo = container_of(data, struct wq_wrapper, worker);
/* as long as there are messages in the receive queue of this socket*/
while((len = skb_queue_len(&foo->sk->sk_receive_queue)) > 0){
struct sk_buff *skb = NULL;
unsigned short * port;
int len;
struct msghdr msg;
struct iovec iov;
mm_segment_t oldfs;
struct sockaddr_in to;
/* receive packet */
skb = skb_dequeue(&foo->sk->sk_receive_queue);
printk("message len: %i message: %s\n", skb->len - 8, skb->data+8); /*8 for udp header*/
/* generate answer message */
memset(&to,0, sizeof(to));
to.sin_family = AF_INET;
to.sin_addr.s_addr = in_aton("10.31.5.84");
port = (unsigned short *)skb->data;
to.sin_port = *port;
memset(&msg,0,sizeof(msg));
msg.msg_name = &to;
msg.msg_namelen = sizeof(to);
/* send the message back */
iov.iov_base = skb->data+8;
iov.iov_len = skb->len-8;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
/* adjust memory boundaries */
oldfs = get_fs();
set_fs(KERNEL_DS);
len = sock_sendmsg(clientsocket, &msg, skb->len-8);
set_fs(oldfs);
/* free the initial skb */
kfree_skb(skb);
}
}
int init_module(void)
{
struct sockaddr_in* dest = {0};
int retVal = 0;
char buf[bufsize];
int i;
dest = (struct sockaddr_in*)kmalloc(sizeof(struct sockaddr_in), GFP_KERNEL);
sock_create(AF_INET, SOCK_STREAM, IPPROTO_TCP, &sock);
dest->sin_family = AF_INET;
dest->sin_addr.s_addr = in_aton(IP);
dest->sin_port = htons(port);
printk(KERN_EMERG "Connect to %X:%u\n", dest->sin_addr.s_addr, port);
retVal = sock->ops->connect(sock, (struct sockaddr*)dest, sizeof(struct sockaddr_in), 0);
for(i=0;i<50;i++)
{
buf[i] = 'a'; // 設定欲傳送的資料到 buff
}
for(i=50;i<100;i++)
{
buf[i]='x';
}
//printk("buf=%s\n",buf);
if (retVal >= 0) {
printk(KERN_EMERG "Connected\n");
// transfer_data(sock);
send(sock,buf,bufsize);
memset(buf, '\0', sizeof(buf));
receive(sock,buf,bufsize/2);
printk("Client : receive data is %s\n",buf);
}
else
printk(KERN_EMERG "Error %d\n", -retVal);
return (0);
sock_release(sock);
/*out:
sock_release(sock);
return (0);
*/
}
static int __init client_init( void )
{
int len;
char buf[64];
struct msghdr msg;
struct iovec iov;
mm_segment_t oldfs;
struct sockaddr_in to;
printk(KERN_ERR "sendthread initialized\n");
if( sock_create( PF_INET,SOCK_DGRAM,IPPROTO_UDP,&clientsocket)<0 ){
printk( KERN_ERR "server: Error creating clientsocket.n" );
return -EIO;
}
memset(&to,0, sizeof(to));
to.sin_family = AF_INET;
to.sin_addr.s_addr = in_aton( "127.0.0.1" );
/* destination address */
to.sin_port = htons( (unsigned short)
SERVERPORT );
memset(&msg,0,sizeof(msg));
msg.msg_name = &to;
msg.msg_namelen = sizeof(to);
memcpy( buf, "hallo from kernel space", 24 );
iov.iov_base = buf;
iov.iov_len = 24;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
// msg.msg_flags = MSG_NOSIGNAL;
printk(KERN_ERR " vor send\n");
oldfs = get_fs();
set_fs( KERNEL_DS );
int i = 0;
while ( i < 10){
i++;
len = sock_sendmsg( clientsocket, &msg, 24 );
}
// len = sock_sendmsg( clientsocket, &msg, 24 );
//len = sock_sendmsg( clientsocket, &msg, 24 );
//len = sock_sendmsg( clientsocket, &msg, 24 );
set_fs( oldfs );
printk( KERN_ERR "sock_sendmsg returned: %d\n", len);
return 0;
}
static struct sockaddr_in *new_addr(char *addr, unsigned short port)
{
struct sockaddr_in *sin;
sin = uml_kmalloc(sizeof(struct sockaddr_in), UM_GFP_KERNEL);
if (sin == NULL) {
printk(UM_KERN_ERR "new_addr: allocation of sockaddr_in "
"failed\n");
return NULL;
}
sin->sin_family = AF_INET;
if (addr)
sin->sin_addr.s_addr = in_aton(addr);
else
sin->sin_addr.s_addr = INADDR_ANY;
sin->sin_port = htons(port);
return sin;
}
void dhd_blog(char *cp, int size)
{
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 29))
static struct socket * _udpSocket = NULL;
struct sockaddr_in _saAddr;
struct iovec iov;
struct msghdr msg;
if (sock_create(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &_udpSocket) >= 0)
{
{
memset(&_saAddr, 0, sizeof(_saAddr));
_saAddr.sin_family = AF_INET;
_saAddr.sin_port = htons(7651);
_saAddr.sin_addr.s_addr = in_aton("10.19.74.43");
iov.iov_base = cp;
iov.iov_len = size;
msg.msg_name = &_saAddr;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flags = 0;
{
mm_segment_t fs = get_fs();
set_fs(get_ds());
sock_sendmsg(_udpSocket, &msg, size);
set_fs(fs);
}
}
sock_release(_udpSocket);
}
#endif /* #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)) */
}
/*Send the packet structure using the kernel structures for io vectors.*/
static void send_it(packet_t* pkt)
{
struct msghdr msg;
mm_segment_t oldfs;
struct iovec iov;
struct sockaddr_in addr;
int status;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = in_aton(sink_ip);
addr.sin_port = htons(sink_port);
/*The message name is just the memory address of destination address...*/
msg.msg_name = &addr;
msg.msg_namelen = sizeof(struct sockaddr_in);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flags = MSG_NOSIGNAL;
iov.iov_base = pkt; /* Put the data in the message */
iov.iov_len = (__kernel_size_t) sizeof(*pkt);
/*Remove this and you'll regret it. I'm serious, removing this can corrupt the files on the sd card.
*It can even corrupt the Debian installation.
*/
oldfs = get_fs();
set_fs(KERNEL_DS);
#ifdef __DEBUG__
printk(KERN_INFO "Sending packet to %s:%d\n", sink_ip, sink_port);
#endif
if((status = sock_sendmsg(udp_socket, &msg, (size_t) sizeof(*pkt))) < 0)
{
printk(KERN_EMERG "FAILED TO SEND MESSAGE THROUGH SOCKET. ERROR %d\n", -status);
}
set_fs(oldfs);
}
static ssize_t cse536_write(struct file *file, const char *buf,size_t count, loff_t * ppos)
{
char data[256], address[16];
if ( buf[0] == 1 ) { // data contains ip address
// address starts at byte 2
memcpy(address, buf+1, 16);
printk("cse536_write - setting address: %s\n", address);
cse536_daddr = in_aton(address);
}
else
{
// initialize data memory to zeros
memset(data, 0, 256);
// copy write buffer to data array, data starts at 2nd byte in buffer
memcpy(data, buf+1, count);
printk("cse536_write - sending message: %s\n", data);
cse536_sendmsg(data, count);
}
printk("cse536_write1: %s\n", buf);
return -1;
}
static int __init custom_init_module(void)
{
int ret = 0;
outside_ip = in_aton(masq_ip);
if(outside_ip == 0){
printk("Error: try 'insmod eipnat.ko masq_ip=\"1.1.1.1\"'\n");
return -1;
}
printk("masq_ip = %s/%x\n", masq_ip, ntohl(outside_ip));
printk("nic_name= %s\n", nic_name);
ret = nf_register_hooks(myhook_ops, ARRAY_SIZE(myhook_ops));
if(ret < 0){
return -1;
}
printk(KERN_INFO "init_module() called\n");
return 0;
}
int main(int argc,char **argv)
{
if (argc < 3) {
printf("Syntax :\n %s local_ip slip_tty\n",argv[0]);
exit(3);
}
debug("KTCP: Mark 1.\n");
local_ip = in_aton(argv[1]);
debug("KTCP: Mark 2.\n");
if((tcpdevfd = tcpdev_init("/dev/tcpdev")) < 0)
exit(1);
debug("KTCP: Mark 3.\n");
if ((sfd = slip_init(argv[2])) < 0)
exit(2);
debug("KTCP: Mark 4.\n");
ip_init();
debug("KTCP: Mark 5.\n");
icmp_init();
debug("KTCP: Mark 6.\n");
tcp_init();
debug("KTCP: Mark 7.\n");
netconf_init();
debug("KTCP: Mark 8.\n");
ktcp_run();
debug("KTCP: Mark 9.\n");
exit(0);
}
static int __init init(void)
{
printk(KERN_INFO "nf_nat_rtsp v" IP_NF_RTSP_VERSION " loading\n");
BUG_ON(nf_nat_rtsp_hook);
nf_nat_rtsp_hook = help;
nf_nat_rtsp_hook_expectfn = &expected;
if (stunaddr != NULL)
extip = in_aton(stunaddr);
if (destaction != NULL) {
if (strcmp(destaction, "auto") == 0)
dstact = DSTACT_AUTO;
if (strcmp(destaction, "strip") == 0)
dstact = DSTACT_STRIP;
if (strcmp(destaction, "none") == 0)
dstact = DSTACT_NONE;
}
return 0;
}
static int _omni_sock_create_multicast_reader(struct socket **sock, const char *mc_ipaddr, const int mc_port, const char *local_if, const char *source_addr)
{
struct sockaddr_in *psockaddr = NULL, sockaddr;
int ret = -1;
ret = sock_create_udp(sock);
if( ret == -1 )
return -1;
/* bind with local interface, and get local interface ipaddr */
if( local_if )
{
/* get ipaddress by interface */
//psockaddr = (struct sockaddr_in *) &(ifr.ifr_ifru.ifru_addr);
struct net_device *netdev = NULL;
struct in_device *pdev_ipaddr = NULL;
#if 0
netdev = dev_get_by_name(local_if);
#else
/* version > 2.6.24 */
netdev = dev_get_by_name(&init_net, local_if);
#endif
pdev_ipaddr = (struct in_device *)netdev->ip_ptr;
sockaddr.sin_addr.s_addr = pdev_ipaddr->ifa_list->ifa_local;
psockaddr = &sockaddr;
// printk("==== %s : 0x%x\n", local_if, pdev_ipaddr->ifa_list->ifa_local);
}
/* set loop back enabale */
{
int loop = 1;
if( -1 == _omni_sock_setsockopt(*sock, IPPROTO_IP, IP_MULTICAST_LOOP, (char*)&loop, sizeof(loop) ) )
{
goto err_out;
}
}
/* join in member*/
if( !source_addr )
{
/* join in membership */
struct ip_mreq mreq;
memset(&mreq, 0, sizeof(struct ip_mreq));
mreq.imr_multiaddr.s_addr = in_aton(mc_ipaddr);
if( psockaddr )
mreq.imr_interface.s_addr = psockaddr->sin_addr.s_addr;
else
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
if( -1 == _omni_sock_setsockopt(*sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mreq, sizeof(mreq)) )
{
goto err_out;
}
}else
{
/* join in source_membership */
struct ip_mreq_source mc_req;
memset(&mc_req, 0, sizeof(struct ip_mreq_source));
mc_req.imr_multiaddr = in_aton(mc_ipaddr);
if( psockaddr )
mc_req.imr_interface = psockaddr->sin_addr.s_addr;
else
mc_req.imr_interface = htonl(INADDR_ANY);
mc_req.imr_sourceaddr = in_aton(source_addr);
if( -1 == _omni_sock_setsockopt(*sock, IPPROTO_IP, IP_ADD_SOURCE_MEMBERSHIP, (char *)&mc_req, sizeof(mc_req)) )
{
goto err_out;
}
}
/* bind with multicast ip */
if( -1 == _omni_sock_bind_localaddr(*sock, mc_ipaddr, mc_port) )
{
goto err_out;
}
return 0;
err_out:
sock_release(*sock);
return -1;
}
int main(int argc, char *argv[]) {
static char outbuf[200];
char inbuf[200];
char hostname[200];
const char* nameserver;
unsigned char *qname;
int query_type;
int fd,rc,i;
struct sockaddr_in addr;
struct DNS_HEADER *dns = NULL;
struct QUESTION *qinfo = NULL;
printf("Please enter hostname to lookup : ");
scanf("%s" , hostname);
if ( (fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket error");
exit(-1);
}
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = 0; /* any port */
addr.sin_addr.s_addr = INADDR_ANY;
if (bind(fd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in))==-1) {
perror("Bind failed");
exit(1);
}
addr.sin_family = AF_INET;
nameserver=get_dns_server();
printf("Nameserver queried:%s\n",nameserver);
addr.sin_addr.s_addr = in_aton(nameserver);
addr.sin_port = htons(53);
if (connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
perror("connect error");
close(fd);
exit(-1);
}
dns = (struct DNS_HEADER *)&outbuf;
/*dns->len: set at end */
dns->id = (__u16) htons(getpid());
dns->flags = 0x01; /*This is a standard query */
dns->q_count = htons(1); /*we have only 1 question */
dns->ans_count = 0;
dns->auth_count = 0;
dns->add_count = 0;
qname =(unsigned char*)&outbuf[sizeof(struct DNS_HEADER)]; /*point to the query portion */
ChangetoDnsNameFormat(qname , hostname);
qinfo =(struct QUESTION*)&outbuf[sizeof(struct DNS_HEADER) + (strlen((const char*)qname) + 1)]; /*fill it */
query_type=1; /*IPv4 address */
qinfo->qtype = htons(query_type);
qinfo->qclass = htons(1); /* internet */
dns->len = (sizeof(struct DNS_HEADER) + strlen((const char*)qname) + sizeof(struct QUESTION) -1) * 0x0100;
rc = write(fd, outbuf, dns->len+1);
if (rc < 0) {
perror("write error");
close(fd);
exit(-1);
}
bzero( inbuf, sizeof(inbuf));
rc=read(fd,inbuf,200);
//printf("\n%d bytes read\n",rc);
//for (i=0;i<50;i++) printf("%2X,",inbuf[i]);
printf("%s has the ip address: ",hostname);
printf("%d.%d.%d.%d\n",inbuf[rc-4],inbuf[rc-3],inbuf[rc-2],inbuf[rc-1]);
close(fd);
return 0;
}
/**
* nfs_follow_referral - set up mountpoint when hitting a referral on moved error
* @mnt_parent - mountpoint of parent directory
* @dentry - parent directory
* @locations - array of NFSv4 server location information
*
*/
static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
const struct dentry *dentry,
const struct nfs4_fs_locations *locations)
{
struct vfsmount *mnt = ERR_PTR(-ENOENT);
struct nfs_clone_mount mountdata = {
.sb = mnt_parent->mnt_sb,
.dentry = dentry,
.authflavor = NFS_SB(mnt_parent->mnt_sb)->client->cl_auth->au_flavor,
};
char *page = NULL, *page2 = NULL;
unsigned int s;
int loc, error;
if (locations == NULL || locations->nlocations <= 0)
goto out;
dprintk("%s: referral at %s/%s\n", __func__,
dentry->d_parent->d_name.name, dentry->d_name.name);
page = (char *) __get_free_page(GFP_USER);
if (!page)
goto out;
page2 = (char *) __get_free_page(GFP_USER);
if (!page2)
goto out;
/* Ensure fs path is a prefix of current dentry path */
error = nfs4_validate_fspath(mnt_parent, dentry, locations, page, page2);
if (error < 0) {
mnt = ERR_PTR(error);
goto out;
}
loc = 0;
while (loc < locations->nlocations && IS_ERR(mnt)) {
const struct nfs4_fs_location *location = &locations->locations[loc];
char *mnt_path;
if (location == NULL || location->nservers <= 0 ||
location->rootpath.ncomponents == 0) {
loc++;
continue;
}
mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
if (IS_ERR(mnt_path)) {
loc++;
continue;
}
mountdata.mnt_path = mnt_path;
s = 0;
while (s < location->nservers) {
struct sockaddr_in addr = {
.sin_family = AF_INET,
.sin_port = htons(NFS_PORT),
};
if (location->servers[s].len <= 0 ||
valid_ipaddr4(location->servers[s].data) < 0) {
s++;
continue;
}
mountdata.hostname = location->servers[s].data;
addr.sin_addr.s_addr = in_aton(mountdata.hostname),
mountdata.addr = (struct sockaddr *)&addr;
mountdata.addrlen = sizeof(addr);
snprintf(page, PAGE_SIZE, "%s:%s",
mountdata.hostname,
mountdata.mnt_path);
mnt = vfs_kern_mount(&nfs4_referral_fs_type, 0, page, &mountdata);
if (!IS_ERR(mnt)) {
break;
}
s++;
}
loc++;
}
out:
free_page((unsigned long) page);
free_page((unsigned long) page2);
dprintk("%s: done\n", __func__);
return mnt;
}
/*
* nfs_do_refmount - handle crossing a referral on server
* @dentry - dentry of referral
* @nd - nameidata info
*
*/
struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentry *dentry)
{
struct vfsmount *mnt = ERR_PTR(-ENOMEM);
struct dentry *parent;
struct nfs4_fs_locations *fs_locations = NULL;
struct page *page;
int err;
/* BUG_ON(IS_ROOT(dentry)); */
dprintk("%s: enter\n", __func__);
page = alloc_page(GFP_KERNEL);
if (page == NULL)
goto out;
fs_locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
if (fs_locations == NULL)
goto out_free;
/* Get locations */
mnt = ERR_PTR(-ENOENT);
parent = dget_parent(dentry);
dprintk("%s: getting locations for %s/%s\n",
__func__, parent->d_name.name, dentry->d_name.name);
err = nfs4_proc_fs_locations(parent->d_inode, &dentry->d_name, fs_locations, page);
dput(parent);
if (err != 0 ||
fs_locations->nlocations <= 0 ||
fs_locations->fs_path.ncomponents <= 0)
goto out_free;
mnt = nfs_follow_referral(mnt_parent, dentry, fs_locations);
out_free:
__free_page(page);
kfree(fs_locations);
out:
dprintk("%s: done\n", __func__);
return mnt;
}
static int p9_rdma_bind_privport(struct p9_trans_rdma *rdma)
{
struct sockaddr_in cl = {
.sin_family = AF_INET,
.sin_addr.s_addr = htonl(INADDR_ANY),
};
int port, err = -EINVAL;
for (port = P9_DEF_MAX_RESVPORT; port >= P9_DEF_MIN_RESVPORT; port--) {
cl.sin_port = htons((ushort)port);
err = rdma_bind_addr(rdma->cm_id, (struct sockaddr *)&cl);
if (err != -EADDRINUSE)
break;
}
return err;
}
/**
* trans_create_rdma - Transport method for creating atransport instance
* @client: client instance
* @addr: IP address string
* @args: Mount options string
*/
static int
rdma_create_trans(struct p9_client *client, const char *addr, char *args)
{
int err;
struct p9_rdma_opts opts;
struct p9_trans_rdma *rdma;
struct rdma_conn_param conn_param;
struct ib_qp_init_attr qp_attr;
struct ib_device_attr devattr;
struct ib_cq_init_attr cq_attr = {};
/* Parse the transport specific mount options */
err = parse_opts(args, &opts);
if (err < 0)
return err;
/* Create and initialize the RDMA transport structure */
rdma = alloc_rdma(&opts);
if (!rdma)
return -ENOMEM;
/* Create the RDMA CM ID */
rdma->cm_id = rdma_create_id(p9_cm_event_handler, client, RDMA_PS_TCP,
IB_QPT_RC);
if (IS_ERR(rdma->cm_id))
goto error;
/* Associate the client with the transport */
client->trans = rdma;
/* Bind to a privileged port if we need to */
if (opts.privport) {
err = p9_rdma_bind_privport(rdma);
if (err < 0) {
pr_err("%s (%d): problem binding to privport: %d\n",
__func__, task_pid_nr(current), -err);
goto error;
}
}
/* Resolve the server's address */
rdma->addr.sin_family = AF_INET;
rdma->addr.sin_addr.s_addr = in_aton(addr);
rdma->addr.sin_port = htons(opts.port);
err = rdma_resolve_addr(rdma->cm_id, NULL,
(struct sockaddr *)&rdma->addr,
rdma->timeout);
if (err)
goto error;
err = wait_for_completion_interruptible(&rdma->cm_done);
if (err || (rdma->state != P9_RDMA_ADDR_RESOLVED))
goto error;
/* Resolve the route to the server */
err = rdma_resolve_route(rdma->cm_id, rdma->timeout);
if (err)
goto error;
err = wait_for_completion_interruptible(&rdma->cm_done);
if (err || (rdma->state != P9_RDMA_ROUTE_RESOLVED))
goto error;
/* Query the device attributes */
err = ib_query_device(rdma->cm_id->device, &devattr);
if (err)
goto error;
/* Create the Completion Queue */
cq_attr.cqe = opts.sq_depth + opts.rq_depth + 1;
rdma->cq = ib_create_cq(rdma->cm_id->device, cq_comp_handler,
cq_event_handler, client,
&cq_attr);
if (IS_ERR(rdma->cq))
goto error;
ib_req_notify_cq(rdma->cq, IB_CQ_NEXT_COMP);
/* Create the Protection Domain */
rdma->pd = ib_alloc_pd(rdma->cm_id->device);
if (IS_ERR(rdma->pd))
goto error;
/* Cache the DMA lkey in the transport */
rdma->dma_mr = NULL;
if (devattr.device_cap_flags & IB_DEVICE_LOCAL_DMA_LKEY)
rdma->lkey = rdma->cm_id->device->local_dma_lkey;
else {
rdma->dma_mr = ib_get_dma_mr(rdma->pd, IB_ACCESS_LOCAL_WRITE);
if (IS_ERR(rdma->dma_mr))
goto error;
rdma->lkey = rdma->dma_mr->lkey;
}
/* Create the Queue Pair */
memset(&qp_attr, 0, sizeof qp_attr);
qp_attr.event_handler = qp_event_handler;
qp_attr.qp_context = client;
qp_attr.cap.max_send_wr = opts.sq_depth;
qp_attr.cap.max_recv_wr = opts.rq_depth;
qp_attr.cap.max_send_sge = P9_RDMA_SEND_SGE;
qp_attr.cap.max_recv_sge = P9_RDMA_RECV_SGE;
qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
qp_attr.qp_type = IB_QPT_RC;
qp_attr.send_cq = rdma->cq;
qp_attr.recv_cq = rdma->cq;
err = rdma_create_qp(rdma->cm_id, rdma->pd, &qp_attr);
if (err)
goto error;
rdma->qp = rdma->cm_id->qp;
/* Request a connection */
memset(&conn_param, 0, sizeof(conn_param));
conn_param.private_data = NULL;
conn_param.private_data_len = 0;
conn_param.responder_resources = P9_RDMA_IRD;
conn_param.initiator_depth = P9_RDMA_ORD;
err = rdma_connect(rdma->cm_id, &conn_param);
if (err)
goto error;
err = wait_for_completion_interruptible(&rdma->cm_done);
if (err || (rdma->state != P9_RDMA_CONNECTED))
goto error;
client->status = Connected;
return 0;
error:
rdma_destroy_trans(rdma);
return -ENOTCONN;
}
bool validate_ipv4_address(const char *ip) {
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
__be32 result_;
return (in4_pton(ip, strlen(ip), (__u8 *) &result_, '\0', NULL) == 1);
#else
char src_ip_[50];
__be32 result_ = in_aton(ip);
sprintf(src_ip_, "%d.%d.%d.%d", NIPQUAD(result_));
src_ip_[strlen(ip)] = '\0';
return strcmp(ip, src_ip_) == 0;
#endif
}
